| /** |
| * \file gpio-test.c |
| * \brief A Documented file. |
| * |
| * Detailed description |
| * \Author: Sniper <js.wang@mobiletek.cn> |
| * \Version: 1.0.0 |
| * \Date: 2022-04-26 |
| */ |
| #include <stdio.h> |
| #include <string.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <errno.h> |
| #include <limits.h> |
| #include <sys/wait.h> |
| #include <unistd.h> |
| #include <sys/mount.h> |
| #include "mbtk_log.h" |
| #include <sys/mman.h> |
| #include <ctype.h> |
| #include <cutils/properties.h> |
| #include "mbtk_gpio_def.h" |
| #include "gpio-define.h" |
| |
| #define gpio_log(...) if(gpio_debug)printf(__VA_ARGS__) |
| #define HWMAP_DEVICE "/dev/hwmap" |
| #define PAGE_OFFS_BITS(pgsz) ((unsigned int)(pgsz)-1) |
| #define PAGE_MASK_BITS(pgsz) (~PAGE_OFFS_BITS(pgsz)) |
| #define STR_MAX_LEN 220 |
| typedef enum { |
| MBTK_ADC0 = 0, /* ADC 0 */ |
| MBTK_ADC1 /* ADC 1 */ |
| } mbtk_adc_enum; |
| |
| static int gpio_debug = 0; |
| |
| /**/ |
| #define GPIO_MAX_CURRENT (7<<10) //设置GPIO最大输出电流 |
| #define GPIO_STRONG_PULLUP (1<<3) //设置GPIO强上拉 |
| #define GPIO_PULLUP_ENABLE ((1<<15)|(1<<14)) //GPIO上拉 |
| #define GPIO_PULLDOWN_ENABLE ((1<<15)|1<<13) //GPIO下拉 |
| |
| #define MBTK_GPIO_OUTPUT 1 |
| #define MBTK_GPIO_INPUT 0 |
| |
| #if (defined(MBTK_PROJECT_L508_X6) || defined(MBTK_PROJECT_T108)) |
| struct gpio_register_function gpio_func_register[128] = { |
| {GPIO_FUNC_GPIO_00, 0}, |
| {GPIO_FUNC_GPIO_01, 0}, |
| {GPIO_FUNC_GPIO_02, 0}, |
| {GPIO_FUNC_GPIO_03, 0}, |
| {GPIO_FUNC_GPIO_04, 0}, |
| {GPIO_FUNC_GPIO_05, 0}, |
| {GPIO_FUNC_GPIO_06, 0}, |
| {GPIO_FUNC_GPIO_07, 0}, |
| {GPIO_FUNC_GPIO_08, 0}, |
| {GPIO_FUNC_GPIO_09, 0}, |
| {GPIO_FUNC_GPIO_10, 0}, |
| {GPIO_FUNC_GPIO_11, 0}, |
| {GPIO_FUNC_GPIO_12, 0}, |
| {GPIO_FUNC_GPIO_13, 0}, |
| {GPIO_FUNC_GPIO_14, 0}, |
| {GPIO_FUNC_GPIO_15, 0}, |
| {GPIO_FUNC_GPIO_16, 0}, |
| {GPIO_FUNC_GPIO_17, 0}, |
| {GPIO_FUNC_GPIO_18, 0}, |
| {GPIO_FUNC_GPIO_19, 0}, |
| {GPIO_FUNC_GPIO_20, 0}, |
| {GPIO_FUNC_GPIO_21, 0}, |
| {GPIO_FUNC_GPIO_22, 0}, |
| {GPIO_FUNC_GPIO_23, 0}, |
| {GPIO_FUNC_GPIO_24, 0}, |
| {GPIO_FUNC_GPIO_25, 0}, |
| {GPIO_FUNC_GPIO_26, 0}, |
| {GPIO_FUNC_GPIO_27, 0}, |
| {GPIO_FUNC_GPIO_28, 0}, |
| {GPIO_FUNC_GPIO_29, 0}, |
| {GPIO_FUNC_GPIO_30, 0}, |
| {GPIO_FUNC_GPIO_31, 0}, |
| {GPIO_FUNC_GPIO_32, 0}, |
| {GPIO_FUNC_GPIO_33, 0}, |
| {GPIO_FUNC_GPIO_34, 0}, |
| {GPIO_FUNC_GPIO_35, 0}, |
| {GPIO_FUNC_GPIO_36, 0}, |
| {GPIO_FUNC_GPIO_37, 0}, // GPIO_37 |
| {GPIO_FUNC_GPIO_38, 0}, // GPIO_38 |
| {GPIO_FUNC_GPIO_39, 0}, // GPIO_39 |
| {GPIO_FUNC_GPIO_40, 0}, // GPIO_40 |
| {GPIO_FUNC_GPIO_41, 0}, //GPIO_41 |
| {GPIO_FUNC_GPIO_42, 0}, //GPIO_42 |
| {GPIO_FUNC_GPIO_43, 0}, //GPIO_43 |
| {GPIO_FUNC_GPIO_44,0}, //GPIO_44 |
| {GPIO_FUNC_GPIO_45,0}, //GPIO_45 |
| {GPIO_FUNC_GPIO_46,0}, //GPIO_46 |
| {GPIO_FUNC_GPIO_47,0}, //GPIO_47 |
| {GPIO_FUNC_SDIO_DAT3, 1}, //GPIO_48 |
| {GPIO_FUNC_GPIO_49, 0}, |
| {GPIO_FUNC_GPIO_50, 0}, |
| {GPIO_FUNC_GPIO_51, 0}, |
| {GPIO_FUNC_GPIO_52, 0}, |
| {GPIO_FUNC_GPIO_53, 0}, |
| {GPIO_FUNC_GPIO_54, 0}, |
| {GPIO_FUNC_SDIO_DAT2, 1}, //GPIO_55 |
| {GPIO_FUNC_SDIO_DAT1, 1}, //GPIO_56 |
| {GPIO_FUNC_SDIO_DAT0, 1}, //GPIO_57 |
| {GPIO_FUNC_SDIO_CMD, 1}, //GPIO_58 |
| {GPIO_FUNC_SDIO_CLK, 1}, //GPIO_59 |
| {GPIO_FUNC_GPIO_60, 0}, |
| {0,0},{0,0},{0,0},{0,0}, |
| {0,0},{0,0}, |
| {GPIO_FUNC_DVL_0, 1},//GPIO_67 |
| {GPIO_FUNC_DVL_1, 1},//GPIO_68 |
| {GPIO_FUNC_GPIO_69, 0}, |
| {GPIO_FUNC_GPIO_70, 0}, |
| {GPIO_FUNC_QSPI_DAT3, 1}, //GPIO_71 |
| {GPIO_FUNC_QSPI_DAT2, 1}, //GPIO_72 |
| {GPIO_FUNC_QSPI_DAT1, 1}, //GPIO_73 |
| {GPIO_FUNC_QSPI_DAT0, 1}, //GPIO_74 |
| {GPIO_FUNC_QSPI_CLK, 1}, //GPIO_75 |
| {GPIO_FUNC_QSPI_CS1, 1}, //GPIO_76 |
| {GPIO_FUNC_GPIO_77, 0}, |
| {GPIO_FUNC_GPIO_78, 0}, |
| {GPIO_FUNC_GPIO_79, 0}, |
| {GPIO_FUNC_GPIO_80, 0}, |
| {GPIO_FUNC_USIM_UCLK, 1},//GPIO_81 |
| {GPIO_FUNC_USIM_UIO, 1},//GPIO_82 |
| {GPIO_FUNC_USIM_URSTn, 1},//GPIO_83 |
| |
| {GPIO_FUNC_MMC1_DAT3,5}, //GPIO_84 |
| {GPIO_FUNC_MMC1_DAT2,5}, //GPIO_85 |
| {GPIO_FUNC_MMC1_DAT1,5}, //GPIO_86 |
| {GPIO_FUNC_MMC1_DAT0,5}, //GPIO_87 |
| {GPIO_FUNC_MMC1_CMD,5}, //GPIO_88 |
| {GPIO_FUNC_MMC1_CLK,5}, //GPIO_89 |
| {GPIO_FUNC_MMC1_CD,1}, //GPIO_90 |
| {0,0}, |
| {0,0},{0,0},{0,0},{0,0}, |
| {0,0},{0,0},{0,0}, |
| {GPIO_FUNC_USB_ID, 1},//GPIO_99 |
| {0,0},{0,0},{0,0},{0,0}, |
| {0,0},{0,0},{0,0},{0,0}, |
| {0,0},{0,0},{0,0},{0,0}, |
| {0,0},{0,0},{0,0},{0,0}, |
| {0,0}, |
| {GPIO_FUNC_PRI_TDI, 1}, //GPIO_117 |
| {GPIO_FUNC_PRI_TMS, 1}, //GPIO_118 |
| {GPIO_FUNC_PRI_TCK, 1}, //GPIO_119 |
| {GPIO_FUNC_PRI_TDO, 1}, //GPIO_120 |
| {GPIO_FUNC_QSPI_VMODE_GPIO, 1}, //GPIO_121 |
| {GPIO_FUNC_VBUS_DRV, 1}, //GPIO_122 |
| {GPIO_FUNC_CLK_REQ, 1}, //GPIO_123 |
| {0,0}, |
| {GPIO_FUNC_VCXO_REQ, 1}, //GPIO_125 |
| {0,0}, //GPIO_126 |
| {GPIO_FUNC_VCXO_OUT, 1}, //GPIO_127 |
| {0,0}, |
| }; |
| |
| #else |
| struct gpio_register_function gpio_func_register[128] = { |
| {GPIO_FUNC_GPIO_00, 0}, |
| {GPIO_FUNC_GPIO_01, 0}, |
| {GPIO_FUNC_GPIO_02, 0}, |
| {GPIO_FUNC_GPIO_03, 0}, |
| {GPIO_FUNC_GPIO_04, 0}, |
| {GPIO_FUNC_GPIO_05, 0}, |
| {GPIO_FUNC_GPIO_06, 0}, |
| {GPIO_FUNC_GPIO_07, 0}, |
| {GPIO_FUNC_GPIO_08, 0}, |
| {GPIO_FUNC_GPIO_09, 0}, |
| {GPIO_FUNC_GPIO_10, 0}, |
| {GPIO_FUNC_GPIO_11, 0}, |
| {GPIO_FUNC_GPIO_12, 0}, |
| {GPIO_FUNC_GPIO_13, 0}, |
| {GPIO_FUNC_GPIO_14, 0}, |
| {GPIO_FUNC_GPIO_15, 0}, |
| {GPIO_FUNC_GPIO_16, 0}, |
| {GPIO_FUNC_GPIO_17, 0}, |
| {GPIO_FUNC_GPIO_18, 0}, |
| {GPIO_FUNC_GPIO_19, 0}, |
| {GPIO_FUNC_GPIO_20, 0}, |
| {GPIO_FUNC_GPIO_21, 0}, |
| {GPIO_FUNC_GPIO_22, 0}, |
| {GPIO_FUNC_GPIO_23, 0}, |
| {GPIO_FUNC_GPIO_24, 0}, |
| {GPIO_FUNC_GPIO_25, 0}, |
| {GPIO_FUNC_GPIO_26, 0}, |
| {GPIO_FUNC_GPIO_27, 0}, |
| {GPIO_FUNC_GPIO_28, 0}, |
| {GPIO_FUNC_GPIO_29, 0}, |
| {GPIO_FUNC_GPIO_30, 0}, |
| {GPIO_FUNC_GPIO_31, 0}, |
| {GPIO_FUNC_GPIO_32, 0}, |
| {GPIO_FUNC_GPIO_33, 0}, |
| {GPIO_FUNC_GPIO_34, 0}, |
| {GPIO_FUNC_GPIO_35, 0}, |
| {GPIO_FUNC_GPIO_36, 0}, |
| {GPIO_FUNC_MMC1_DAT3, 5}, // GPIO_37 |
| {GPIO_FUNC_MMC1_DAT2, 5}, // GPIO_38 |
| {GPIO_FUNC_MMC1_DAT1, 5}, // GPIO_39 |
| {GPIO_FUNC_MMC1_DAT0, 5}, // GPIO_40 |
| {GPIO_FUNC_MMC1_CMD, 5}, //GPIO_41 |
| {GPIO_FUNC_MMC1_CLK, 5}, //GPIO_42 |
| {GPIO_FUNC_MMC1_CD , 1}, //GPIO_43 |
| {0,0},{0,0},{0,0},{0,0}, |
| {GPIO_FUNC_SDIO_DAT3, 1}, //GPIO_48 |
| {GPIO_FUNC_GPIO_49, 0}, |
| {GPIO_FUNC_GPIO_50, 0}, |
| {GPIO_FUNC_GPIO_51, 0}, |
| {GPIO_FUNC_GPIO_52, 0}, |
| {GPIO_FUNC_GPIO_53, 0}, |
| {GPIO_FUNC_GPIO_54, 0}, |
| {GPIO_FUNC_SDIO_DAT2, 1}, //GPIO_55 |
| {GPIO_FUNC_SDIO_DAT1, 1}, //GPIO_56 |
| {GPIO_FUNC_SDIO_DAT0, 1}, //GPIO_57 |
| {GPIO_FUNC_SDIO_CMD, 1}, //GPIO_58 |
| {GPIO_FUNC_SDIO_CLK, 1}, //GPIO_59 |
| {GPIO_FUNC_GPIO_60, 0}, |
| {0,0},{0,0},{0,0},{0,0}, |
| {0,0},{0,0}, |
| {GPIO_FUNC_DVL_0, 1},//GPIO_67 |
| {GPIO_FUNC_DVL_1, 1},//GPIO_68 |
| {GPIO_FUNC_GPIO_69, 0}, |
| {GPIO_FUNC_GPIO_70, 0}, |
| {GPIO_FUNC_QSPI_DAT3, 1}, //GPIO_71 |
| {GPIO_FUNC_QSPI_DAT2, 1}, //GPIO_72 |
| {GPIO_FUNC_QSPI_DAT1, 1}, //GPIO_73 |
| {GPIO_FUNC_QSPI_DAT0, 1}, //GPIO_74 |
| {GPIO_FUNC_QSPI_CLK, 1}, //GPIO_75 |
| {GPIO_FUNC_QSPI_CS1, 1}, //GPIO_76 |
| {GPIO_FUNC_GPIO_77, 0}, |
| {GPIO_FUNC_GPIO_78, 0}, |
| {GPIO_FUNC_GPIO_79, 0}, |
| {GPIO_FUNC_GPIO_80, 0}, |
| {GPIO_FUNC_USIM_UCLK, 1},//GPIO_81 |
| {GPIO_FUNC_USIM_UIO, 1},//GPIO_82 |
| {GPIO_FUNC_USIM_URSTn, 1},//GPIO_83 |
| {0,0},{0,0},{0,0},{0,0}, |
| {0,0},{0,0},{0,0},{0,0}, |
| {0,0},{0,0},{0,0},{0,0}, |
| {0,0},{0,0},{0,0}, |
| {GPIO_FUNC_USB_ID, 1},//GPIO_99 |
| {0,0},{0,0},{0,0},{0,0}, |
| {0,0},{0,0},{0,0},{0,0}, |
| {0,0},{0,0},{0,0},{0,0}, |
| {0,0},{0,0},{0,0},{0,0}, |
| {0,0}, |
| {GPIO_FUNC_PRI_TDI, 1}, //GPIO_117 |
| {GPIO_FUNC_PRI_TMS, 1}, //GPIO_118 |
| {GPIO_FUNC_PRI_TCK, 1}, //GPIO_119 |
| {GPIO_FUNC_PRI_TDO, 1}, //GPIO_120 |
| {GPIO_FUNC_QSPI_VMODE_GPIO, 1}, //GPIO_121 |
| {GPIO_FUNC_VBUS_DRV, 1}, //GPIO_122 |
| {GPIO_FUNC_CLK_REQ, 1}, //GPIO_123 |
| {0,0}, |
| {GPIO_FUNC_VCXO_REQ, 1}, //GPIO_125 |
| {GPIO_FUNC_VCXO_OUT, 1}, //GPIO_126 |
| {0,0}, |
| }; |
| |
| #endif |
| |
| static int mbtk_gpio_adc(channel) |
| { |
| int ret = 0; |
| |
| ret = mbtk_adc_get(channel); |
| //printf("ADC_%d_value =%d\n", channel, ret); |
| if(ret >= 500 ){ |
| ret = 1; |
| } |
| else if (ret>=0 && ret<=480){ |
| ret = 0; |
| } |
| else{ |
| ret = -1; |
| } |
| return ret; |
| } |
| |
| |
| static int hwacc_register(int rw, unsigned int addr, unsigned int *data) |
| { |
| int fid; |
| unsigned int pagesize, len, len_aligned; |
| unsigned int addr_aligned; |
| volatile unsigned int *pa; |
| void *vpa; |
| |
| len = pagesize = sysconf(_SC_PAGESIZE); |
| if((fid = open(HWMAP_DEVICE, O_RDWR)) < 0) |
| { |
| printf("Failed to open %s\n", HWMAP_DEVICE); |
| exit(-1); |
| } |
| |
| // Align the length so the mapped area is page-aligned and contains the requested area |
| addr_aligned = addr & PAGE_MASK_BITS(pagesize); |
| len_aligned =((addr + len - addr_aligned) + pagesize - 1) & PAGE_MASK_BITS(pagesize); |
| |
| /* Notes on flags: MAP_PRIVATE results in copy on write; MAP_SHARED allows normal write */ |
| /* MAP_SHARED required O_RDWR in open above, otherwise mmap fails with errno=EACCES */ |
| /* Notes on prot: PROT_WRITE allows read and write; PROT_READ allows read only */ |
| /* Notes on off: an unsigned 32-bit value, should be aligned to page size according to mmap manpage */ |
| if((vpa = mmap(0, len_aligned, PROT_READ|PROT_WRITE, MAP_SHARED, fid, addr_aligned)) == MAP_FAILED) |
| { |
| printf("mmap failed (%d)\n", errno); |
| } |
| else |
| { |
| pa = (volatile unsigned int *)((unsigned char *)vpa + (addr & PAGE_OFFS_BITS(pagesize))); |
| if(rw == 0) |
| { |
| *data = *pa; |
| gpio_log("Value read from 0x%.8x via MVA=0x%p is 0x%.8x\n", addr, pa, *data); |
| } |
| else if(rw == 1) |
| { |
| *pa = *data; |
| gpio_log("Value %.8x written to 0x%.8x via MVA=0x%p\n", *data, addr, pa); |
| #if defined(HWACC_DEBUG) |
| { |
| unsigned int val; |
| val = *pa; |
| printf("Value read from 0x%.8x via MVA=0x%p is 0x%.8x\n", addr, pa, val); |
| } |
| #endif |
| } |
| munmap(vpa, len); |
| } |
| |
| close(fid); |
| return 0; |
| } |
| /* |
| 设置GPIO 模式：第一步读GPIO22默认function |
| root@OpenWrt:/# hwacc r 0xd401e134 |
| Option = r Addr = d401e134 |
| Value read from 0xd401e134 via MVA=0x0xb6fc3134 is 0x0000d040 //默认GPIO功能 |
| Bit0~bit2值对应上面表格各function，0代表GPIO功能 |
| */ |
| static int gpio_register_read(int reg) |
| { |
| int ret = -1; |
| #if 0 |
| FILE * fp; |
| // "/bin/hwacc r 0xd401e134"; |
| char command[36] = {0}; |
| char buffer[1024]; |
| int i = 0; |
| |
| sprintf(command, "/bin/hwacc r 0x%x", reg); |
| fp = popen(command, "r"); |
| while(1) |
| { |
| if( fgets (buffer, sizeof(buffer), fp)!=NULL ) { |
| buffer[strlen(buffer) - 1] = 0; |
| // gpio_log("out [%d]: %s\n", strlen(buffer), buffer); |
| }else{ |
| break; |
| } |
| i = strstr_n(buffer, "is"); |
| if(i) |
| { |
| ret = str_to_hex(&buffer[i + 2]); |
| gpio_log("read 0x%x value:%s, %x\n", reg, &buffer[i + 2], ret); |
| } |
| } |
| pclose(fp); |
| #else |
| #ifndef MBTK_PROJECT_PN1803 |
| usleep(50); |
| #endif |
| hwacc_register(0, reg, &ret); |
| #ifndef MBTK_PROJECT_PN1803 |
| usleep(50); |
| #endif |
| #endif |
| return ret; |
| } |
| /* |
| 设置输入输出状态，设置PDR寄存器GPIO22为output |
| root@OpenWrt:/# hwacc w 0xD401900c 0x00c03800 |
| Option = w Addr = d401900c Data=00c03800 |
| Value 00c03800 written to 0xd401900c via MVA=0x0xb6f9f00c |
| */ |
| static void gpio_register_write(int reg, int value) |
| { |
| #if 0 |
| FILE * fp; |
| // "/bin/hwacc w 0xD401900c 0x00c03800" |
| char command[36] = {0}; |
| char buffer[1024]; |
| |
| sprintf(command, "/bin/hwacc w 0x%x 0x%x", reg, value); |
| gpio_log("command: %s\n", command); |
| fp = popen(command, "r"); |
| while(1) |
| { |
| if( fgets (buffer, sizeof(buffer), fp)!=NULL ) { |
| gpio_log("%s\n", buffer); |
| }else{ |
| break; |
| } |
| } |
| pclose(fp); |
| |
| #else |
| #ifndef MBTK_PROJECT_PN1803 |
| usleep(50); |
| #endif |
| hwacc_register(1, reg, &value); |
| #ifndef MBTK_PROJECT_PN1803 |
| usleep(50); |
| #endif |
| #endif |
| } |
| /* |
| AF SEL<p>This field is used for alternate function selection for a pin. |
| It selects between the eight possible alternate functions for the pin. |
| Alternate function 0 is always the reset case. |
| |
| <p>0x0 = Alternate function 0 (primary function at reset) |
| <p>0x1 = Alternate function 1 |
| <p>0x2 = Alternate function 2 |
| <p>0x3 = Alternate function 3 |
| <p>0x4 = Alternate function 4 |
| <p>0x5 = Alternate function 5 |
| <p>0x6 = Alternate function 6 |
| <p>0x7 = Alternate function 7 |
| */ |
| static int gpio_register_set_func_0(int port) |
| { |
| int ret; |
| struct gpio_register_function *reg = NULL; |
| if(port > 128) |
| return -1; |
| reg = &gpio_func_register[port]; |
| if(0 == reg->reg) |
| return -1; |
| ret = gpio_register_read(reg->reg); |
| if((ret & 0x7) != reg->func_gpio) |
| { |
| //printf("Gpio set func [%d] [0x%x]!\n", reg->func_gpio, (ret & 0xfffffff8) | reg->func_gpio); |
| gpio_register_write(reg->reg, (ret & 0xfffffff8) | reg->func_gpio); |
| } |
| return 0; |
| } |
| /* |
| 设置GPIO 方向 |
| 读取输入输出状态，读PDR寄存器：0x0c |
| root@OpenWrt:/# hwacc r 0xD401900c |
| Option = r Addr = d401900c |
| Value read from 0xd401900c via MVA=0x0xb6f3900c is 0x00803800 //bit22为0，代表Input |
| */ |
| static void gpio_register_set_direction(int port, int dir) |
| { |
| int ret; |
| int reg = 0xD4019000; |
| |
| if(port > (32 - 1)) |
| reg = 0xD4019004; |
| if(port > (32 * 2 - 1)) |
| reg = 0xD4019008; |
| if(port > (32 * 3 - 1)) |
| reg = 0xD4019100; |
| |
| reg += 0x0c; |
| port = port % 0x20; |
| ret = gpio_register_read(reg); |
| //printf("[Direction] reg_value=%x\n", ret); |
| // 设置 输出 0 && 1 |
| if(!(ret & (0x1 << port)) && dir) |
| { |
| gpio_register_write(reg, ret | (0x1 << port)); //set the gpio bit |
| //printf("[Direction out] reg_value=%x\n", gpio_register_read(reg)); |
| } |
| // 设置 输入 1 && 0 |
| if((ret & (0x1 << port)) && !dir) |
| { |
| #if 1 |
| gpio_register_write(reg, ret & (~(0x1 << port))); //clear the gpio bit,mbtk_tanggaoyou |
| #else |
| gpio_register_write(reg, ret | !(0x1 << port)); //这是错误配置，实际没有任何作用，还是原来的值 |
| #endif |
| //printf("[Direction in] reg_value=%x\n", gpio_register_read(reg)); |
| } |
| } |
| /* |
| 设置GPIO 输出电平 |
| |
| 读取电平状态，先读PLR寄存器：0x00 |
| root@OpenWrt:/# hwacc r 0xD4019000 |
| Option = r Addr = d4019000 |
| Value read from 0xd4019000 via MVA=0x0xb6f1c000 is 0x81e82a30 |
| 对应下面具体BIT |
| 1000 0001 1110 1000 0010 1010 0011 0000 BIT22默认电平高 |
| |
| 设置输出高：设置PSR寄存器：0x18（只写寄存器） |
| root@OpenWrt:/# hwacc w 0xD4019018 0x400000 |
| Option = w Addr = d4019018 Data=00400000 |
| Value 00400000 written to 0xd4019018 via MVA=0x0xb6f56018 //bit22写1，输出高 |
| |
| 设置输出低：设置PCR寄存器：0x24 |
| root@OpenWrt:/# hwacc w 0xD4019024 0x400000 |
| Option = w Addr = d4019024 Data=00400000 |
| Value 00400000 written to 0xd4019024 via MVA=0x0xb6faa024 //Bit22写1，GPIO22输出低 |
| |
| */ |
| static void gpio_register_set_value(int port, int value) |
| { |
| int ret; |
| int reg = 0xD4019000; |
| |
| if(port > (32 - 1)) |
| reg = 0xD4019004; |
| if(port > (32 * 2 - 1)) |
| reg = 0xD4019008; |
| if(port > (32 * 3 - 1)) |
| reg = 0xD4019100; |
| |
| if(value) |
| { |
| reg += 0x18; |
| } |
| else |
| reg += 0x24; |
| |
| port = port % 0x20; |
| ret = gpio_register_read(reg); |
| //printf("[Value] reg_value=%x\n", gpio_register_read(0xD4019004)); |
| // 设置 高电平 0 && 1 |
| if(value) |
| { |
| gpio_register_write(reg, ret | (0x1 << port)); |
| //printf("[Value high] reg_value=%x\n", gpio_register_read(0xD4019004)); |
| return; |
| } |
| // 设置 低电平 1 && 0 |
| if(!(ret & (0x1 << port)) && !value) |
| { |
| gpio_register_write(reg, ret | (0x1 << port)); |
| //printf("[Value low] reg_value=%x\n", gpio_register_read(0xD4019004)); |
| } |
| } |
| /* |
| 读取电平状态，先读PLR寄存器：0x00 |
| root@OpenWrt:/# hwacc r 0xD4019000 |
| Option = r Addr = d4019000 |
| Value read from 0xd4019000 via MVA=0x0xb6f1c000 is 0x81e82a30 |
| 对应下面具体BIT |
| 1000 0001 1110 1000 0010 1010 0011 0000 BIT22默认电平高 |
| */ |
| static int gpio_register_get_value(int port) |
| { |
| int ret = -1; |
| int reg = 0xD4019000; |
| |
| if(port > (32 - 1)) |
| reg = 0xD4019004; |
| if(port > (32 * 2 - 1)) |
| reg = 0xD4019008; |
| if(port > (32 * 3 - 1)) |
| reg = 0xD4019100; |
| port = port % 0x20; |
| ret = gpio_register_read(reg); |
| if(ret & (0x1 << port)) |
| { |
| return 1; |
| } |
| return 0; |
| } |
| |
| void gpio_debug_set(int enable) |
| { |
| gpio_debug = enable; |
| } |
| |
| |
| |
| #if defined(MBTK_PROJECT_PN1803) |
| int gpio_register_test_out(int port, int value) |
| { |
| int ret; |
| int i; |
| int valueh = 0; |
| int valuel = 1; |
| |
| //printf("Gpio port [%d] test start!\n", port); |
| ret = gpio_register_set_func_0(port); //设功能为GPIO |
| if(ret){ |
| printf("gpio_port can't support!\n"); |
| return -1; |
| } |
| gpio_register_set_direction(port, 1); //设方向为输出 |
| ret = gpio_register_get_value(port); |
| //printf("gpio default value is : %d.\n", ret); |
| |
| |
| //[High] |
| for(i = 0; i <= 10; i++){ |
| gpio_register_set_value(port, 1); |
| usleep(50); |
| valueh = gpio_register_get_value(port); |
| //printf("set high? %d\n",valueh); |
| if(1 == valueh){ |
| break; |
| } |
| } |
| //usleep(10000); |
| for(i = 0; i <= 35; i++){ |
| ret = mbtk_gpio_adc(0); |
| usleep(3000); |
| if(1 == ret){ |
| break; |
| } |
| } |
| if(1 != ret){ |
| ret=-1; |
| goto exit; |
| } |
| printf("******gpio should is high: %d.******\n", ret); |
| |
| |
| //[Low] |
| usleep(200); |
| for(i = 0; i <= 10; i++){ |
| gpio_register_set_value(port, 0); //输出低 |
| usleep(50); |
| valuel = gpio_register_get_value(port); |
| //printf("set low? %d\n",valuel); |
| if(0 == valuel){ |
| break; |
| } |
| } |
| //usleep(10000); |
| for(i = 0; i <= 35; i++){ |
| ret = mbtk_gpio_adc(0); |
| usleep(3000); |
| if(0 == ret){ |
| break; |
| } |
| } |
| printf("******gpio should is low: %d.******\n", ret); |
| if(0 != ret){ |
| ret=-1; |
| goto exit; |
| } |
| |
| exit: |
| //gpio_register_set_direction(port, 0); //设方向为输入 |
| return ret; |
| } |
| |
| int mbtk_at_gpio(bool gnss_support, void* arg) |
| { |
| int test_gpio[] = { |
| 56, 55, 58, 57, 48, 59, 12, 20, 5, 43, 21, |
| 49, 50, 27, 28, 26, 25, 16, 17, 15, 126, 125, |
| 4, 0, 3, 18, 7, 6, 1, 2, /*54,*/ 19, 13, |
| 32, 31, 23, 24, 22, /*122,*/ 33, 35, 36, 34, 14, |
| 99,/* 53,*/ 37, 38, 39, 40, 41, 42}; |
| |
| int i, j, ret, total, n = 0; |
| int *fail_io = (int *)arg; |
| total = (sizeof(test_gpio)/sizeof(int)); |
| //printf("Start test gpio total: %d\n", total); |
| |
| /* [1 all gpio set to low] */ |
| for(j = 0; j < 6 ; j++){ |
| for(i = 0; i < total; i++){ |
| gpio_register_set_func_0(test_gpio[i]); |
| gpio_register_set_direction(test_gpio[i], 1); |
| gpio_register_set_value(test_gpio[i], 0); |
| } |
| //usleep(10000); |
| for(i = 0; i <= 35; i++){ |
| ret = mbtk_gpio_adc(0); |
| usleep(3000); |
| if(0 == ret){ |
| break; |
| } |
| } |
| printf("pre set ADC: %d, times: %d\n",ret, j); |
| if(0 == ret){ |
| break; |
| } |
| } |
| if(0 != ret){ |
| printf("Fail, please retest"); |
| return -1; |
| } |
| |
| |
| /* [2 GPIOTEST] */ |
| for(i = 0; i < total; i++){ |
| ret = gpio_register_test_out(test_gpio[i], 0); |
| if(-1 == ret){ |
| printf("!!!!!!!!!!!!gpio [%d] test failed!!!!!!!!!!!!\n", test_gpio[i]); |
| fail_io[n] = test_gpio[i]; |
| n++; |
| }else{ |
| //printf("############gpio [%d] test success############\n", test_gpio[i]); |
| } |
| } |
| mbtk_adc_close(); |
| return n; |
| } |
| |
| #elif defined(MBTK_PROJECT_L508) |
| |
| int test_gpio[] = |
| { |
| 0,2,1,6,16,15,17,99, |
| 34,36,35,33,14,49,50,12,118,120, |
| 43,19,7,3, |
| 20,59,126,117,125,18,56,55,58,48,57,5,4,21, |
| 23,24,13,27,28,26,25, |
| 32,31, |
| 54, |
| 53,123,122 |
| }; |
| int total; |
| total = (sizeof(test_gpio)/sizeof(int)); |
| |
| |
| int gpio_test_init(void) |
| { |
| int i,j,ret; |
| //int *fail_io = (int *)arg; |
| printf("[init] L508 XX GPIOTEST v1.2 \n"); |
| system("i2cset -y -f 2 0x31 0x12 0x46"); |
| system("echo 53 > /sys/class/gpio/export"); //gnss uart rx |
| system("echo out > /sys/class/gpio/gpio53/direction"); |
| system("echo 54 > /sys/class/gpio/export");//gnss uart tx |
| system("echo out > /sys/class/gpio/gpio54/direction"); |
| system("echo 22 > /sys/class/gpio/export");//check pin |
| |
| gpio_register_set_func_0(22); |
| gpio_register_set_direction(22, 1); //输出 |
| |
| usleep(500); |
| /* |
| GPIO22默认是上拉，如果改成GPIO输入模式，其PIN脚电压是高电平，必须改成下拉后GPIO22才处于低电平状态，否则测试PIN拉低失败 |
| */ |
| gpio_register_set_direction(22, MBTK_GPIO_INPUT); //设置输入模式 |
| gpio_register_write(GPIO_FUNC_GPIO_22,0xb040); //PULL DOWN |
| |
| |
| /* [1 all gpio set to low] */ |
| for(j = 0; j < 6 ; j++){ |
| for(i = 0; i < total; i++){ |
| gpio_register_set_func_0(test_gpio[i]); |
| gpio_register_set_direction(test_gpio[i], 1); |
| gpio_register_set_value(test_gpio[i], 0); |
| } |
| |
| for(i = 0; i <= 5; i++){ |
| ret = gpio_register_get_value(22); |
| |
| if(0 == ret){ |
| break; |
| } |
| |
| usleep(3000); |
| |
| } |
| |
| printf("pre set ADC: %d, times: %d\n",ret, j); |
| |
| if(0 == ret){ |
| break; |
| } |
| } |
| |
| if(0 != ret){ |
| printf("set all low Fail, please retest\n"); |
| return -1; |
| } |
| |
| printf("pre set SUCCESS\n"); |
| |
| return 0; |
| } |
| |
| int gpio_test(void* arg) |
| { |
| int ret,i,j; |
| int *fail_io = (int *)arg; |
| int n = 0; |
| int gpio_num = 0; |
| for(i = 0; i < total; i++){ |
| |
| gpio_num = test_gpio[i]; |
| |
| //ret = gpio_register_get_value(test_gpio[i]); |
| //printf("GPIO%d default value? %d\n", test_gpio[i], ret); |
| |
| //set high |
| gpio_register_set_value(gpio_num, 1); |
| |
| ret = gpio_register_get_value(gpio_num); |
| |
| printf("GPIO%d set high= %d\n", gpio_num, ret); |
| |
| //get |
| ret = gpio_register_get_value(22); |
| |
| if(1 != ret){ |
| printf("gpio [%d] test high failed\n", gpio_num); |
| |
| fail_io[n] = gpio_num; |
| |
| n++; |
| }else{ |
| printf("gpio[%d] test high success\n", gpio_num); |
| } |
| |
| //set low |
| gpio_register_set_value(gpio_num, 0); |
| |
| //ret = gpio_register_get_value(test_gpio[i]); |
| //printf("GPIO%d set low? %d\n", test_gpio[i], ret); |
| |
| //get |
| ret = gpio_register_get_value(22); |
| |
| if(0 != ret){ |
| printf("gpio [%d] test low failed\n", gpio_num); |
| |
| fail_io[n] = test_gpio[i]; |
| |
| n++; |
| }else{ |
| printf("gpio [%d] test low success\n", gpio_num); |
| } |
| } |
| return n; |
| } |
| |
| |
| |
| |
| int mbtk_at_gpio(bool gnss_support, void* arg) |
| { |
| int i, j, ret, total, n = 0; |
| //int *fail_io = (int *)arg; |
| |
| n = gpio_test_init(); |
| |
| if(-1 == n) |
| { |
| //return -1; |
| } |
| |
| n = gpio_test(arg); |
| |
| system("echo 53 > /sys/class/gpio/unexport"); //unexport gnss uart rx |
| system("echo 54 > /sys/class/gpio/unexport");//unexportgnss uart tx |
| system("echo 22 > /sys/class/gpio/unexport");//unexportcheck pin |
| |
| printf("\n[GPIOTEST] Finished !!\n\n"); |
| |
| return n; |
| } |
| |
| |
| |
| #elif defined(MBTK_PROJECT_L509) |
| #define DEBUG_GPIO_TEST 0 |
| mbtk_gpio_paired_info_struct test_pin_array[] ={ //是GPIO_array |
| //output_pin, output_gpio,input_gpio,input_pin,test_result |
| //120 5 33 这几个输入脚没法正常设置为输入 |
| //{?,52,51,?,0}, //拉不低 没有这一组 |
| //{?,54,53,?,0}, |
| //Opin,Ogpio,Igpio,Ipin,res |
| {122, 16, 17, 121, 0}, //output_pin, output_gpio,input_gpio,input_pin,test_result |
| {1, 117, 120, 2, 0}, |
| //{?,118,19,13,?,0}, //usim |
| {5, 123, 126, 6, 0}, |
| {23, 43, 23, 62, 0}, |
| {24, 28, 27, 25, 0}, |
| {26, 26, 25, 27, 0}, |
| {37, 34, 33, 40, 0}, |
| {38, 36, 35, 39, 0}, |
| {41, 49, 50, 42, 0}, |
| {64, 32, 31, 65, 0}, |
| {78, 7, 2, 73, 0}, |
| {77, 6, 1, 76, 0}, |
| {81, 15, 3, 75, 0}, |
| {74, 0, 18, 120,0}, |
| {79, 4, 5, 82, 0}, |
| {80, 13, 14, 84, 0}, |
| {129, 48, 55, 130,0}, |
| {131, 56, 57, 132,0}, |
| {133, 59, 58, 134,0}, |
| {135, 21, 99, 139,0}, |
| //{?,20,22,?,0}, //拉不低 |
| //{?,12,122,?,0}, //拉不低 122好像不该用 |
| }; |
| //测低 |
| uint16 mbtk_gpio_test_all_low(mbtk_gpio_paired_info_struct *pin_array, uint16 MAX_pin_num) |
| { |
| uint16 index =0; |
| uint16 OUT_pin, Read_pin; |
| uint32 read_high_value; |
| uint32 read_low_value; |
| uint16 fail_num=0; |
| int res; |
| |
| printf("[GPIOTEST][run test all pin low]\n"); |
| |
| |
| for(index = 0; index < MAX_pin_num; index++){ |
| OUT_pin = pin_array[index].output_gpio; |
| Read_pin = pin_array[index].input_gpio; |
| |
| //输出低 |
| gpio_register_set_direction(OUT_pin,1); |
| gpio_register_set_value(OUT_pin, 0); |
| |
| //输入脚设为输入 |
| gpio_register_set_direction(Read_pin,0); |
| } |
| |
| for(index = 0; index < MAX_pin_num; index++){ |
| OUT_pin = pin_array[index].output_gpio; |
| Read_pin = pin_array[index].input_gpio; |
| read_low_value = gpio_register_get_value(Read_pin); |
| //结果检测 |
| if(read_low_value != 0){ |
| printf("[GPIOTEST][!Low Failed!]: GPIO%d PIN%d\n", Read_pin,pin_array[index].input_pin); |
| pin_array[index].mbtk_gpio_test_result = 1; |
| fail_num ++; |
| } |
| else{ |
| #if DEBUG_GPIO_TEST |
| printf("[GPIOTEST][-Low Success-]: GPIO%d \n", Read_pin); |
| #endif |
| } |
| } |
| return fail_num; |
| |
| } |
| |
| |
| |
| //测高 |
| uint16 mbtk_gpio_test_pin_high(mbtk_gpio_paired_info_struct *pin_array,uint16 MAX_pin_num) |
| { |
| uint16 index =0; |
| uint16 OUT_pin, Read_pin; |
| uint32 read_high_value; |
| uint32 read_low_value; |
| uint16 fail_num=0; |
| int i = 0; |
| |
| printf("[GPIOTEST][run test pin high]\n"); |
| |
| for(index = 0;index<MAX_pin_num;index++) |
| { |
| OUT_pin = pin_array[index].output_gpio; |
| Read_pin = pin_array[index].input_gpio; |
| |
| //设高 |
| gpio_register_set_direction(OUT_pin,1); |
| gpio_register_set_direction(Read_pin,0); |
| gpio_register_set_value(OUT_pin, 1); |
| usleep(20000); |
| read_high_value = gpio_register_get_value(Read_pin); |
| #if DEBUG_GPIO_TEST |
| printf("[GPIOTEST][test_high]: PIN%d: get value =%d \n", pin_array[index].input_pin, read_high_value); |
| #endif |
| |
| //设高后重新设低 |
| usleep(20000); |
| gpio_register_set_value(OUT_pin, 0); |
| usleep(80000); |
| //read_low_value = gpio_register_get_value(Read_pin); |
| //read_low_value = gpio_register_get_value(Read_pin); |
| for(i = 0;i < 10; i++){ |
| read_low_value = gpio_register_get_value(Read_pin); |
| if(0 == read_low_value){ |
| break; |
| } |
| usleep(20000); |
| } |
| #if DEBUG_GPIO_TEST |
| printf("[GPIOTEST][test_low]: PIN%d: get value =%d \n", pin_array[index].input_pin, read_low_value); |
| #endif |
| if(read_high_value != 1||read_low_value !=0) |
| { |
| printf("[GPIOTEST][!High Failed!]: Gpio%d PIN%d\n",Read_pin,pin_array[index].input_pin); |
| pin_array[index].mbtk_gpio_test_result = 2; |
| fail_num ++; |
| } |
| else{ |
| #if DEBUG_GPIO_TEST |
| printf("[GPIOTEST][-High Success-]: Gpio%d \n", Read_pin); |
| #endif |
| } |
| } |
| return fail_num; |
| |
| } |
| void gpio_test_init_test_gpio_mode(mbtk_gpio_paired_info_struct pin_array[],int MAX_pin_num) |
| { |
| int index =0; |
| int OUT_pin, Read_pin; |
| |
| printf("[GPIOTEST] L509 GPIOTEST v2.1 --init\n"); |
| |
| for(index = 0;index<MAX_pin_num;index++) |
| { |
| OUT_pin = pin_array[index].output_gpio; |
| Read_pin = pin_array[index].input_gpio; |
| pin_array[index].mbtk_gpio_test_result = 0; //init as passed |
| gpio_register_set_func_0(OUT_pin); |
| gpio_register_set_func_0(Read_pin); |
| } |
| |
| //gpio_register_set_func_0(); |
| system("i2cset -y -f 2 0x31 0x12 0x46"); |
| system("echo 33 > /sys/class/gpio/export"); |
| system("echo 120 > /sys/class/gpio/export"); |
| system("echo 126 > /sys/class/gpio/export"); |
| system("echo in > /sys/class/gpio/gpio126/direction"); |
| system("echo in > /sys/class/gpio/gpio120/direction"); |
| system("echo in > /sys/class/gpio/gpio5/direction"); |
| system("echo in > /sys/class/gpio/gpio33/direction"); |
| #if DEBUG_GPIO_TEST |
| printf("[GPIOTEST]gpio_test_init_test_gpio_mode FINISH\n"); |
| #endif |
| |
| } |
| |
| |
| int mbtk_at_gpio(bool gnss_support, void* arg) |
| { |
| int i, num; |
| int *fail_io = (int *)arg; |
| /*OPEN SWITCH */ |
| uint16 test_fail_count = 0; |
| uint16 test_MAX_pin_num = 0; |
| char buf[STR_MAX_LEN]; |
| uint16 str_len=0; |
| uint16 temp_len =0; |
| uint16 Out_pin; |
| uint16 in_pin; |
| uint16 fail_print_num = 0; |
| |
| gpio_register_set_func_0(125); |
| gpio_register_set_direction(125, 1); |
| gpio_register_set_value(125, 1); //开关使能脚 |
| |
| |
| /* [3]初始化待测GPIO */ |
| test_MAX_pin_num = sizeof(test_pin_array)/sizeof(test_pin_array[0]); |
| |
| gpio_test_init_test_gpio_mode(test_pin_array,test_MAX_pin_num); |
| |
| |
| |
| /* [4]测试过程 */ |
| test_fail_count = mbtk_gpio_test_all_low(test_pin_array,test_MAX_pin_num); |
| |
| if(!test_fail_count) //set all pin low passed |
| { |
| printf("[GPIOTEST]set all pin low: passed\n"); |
| test_fail_count = mbtk_gpio_test_pin_high(&test_pin_array,test_MAX_pin_num); |
| } |
| else |
| { |
| printf("[GPIOTEST]set all pin low: failed num=%d!!!\n",test_fail_count); |
| } |
| |
| |
| //memset(buf,0,STR_MAX_LEN); |
| |
| /* [5]测试结果检测 */ |
| if(test_fail_count ) |
| { |
| //printf( "GPIOTEST Fail %02d PINs:\n", test_fail_count*2); |
| sprintf(buf, "GPIOTEST Fail %02d PINs:", test_fail_count*2); |
| temp_len = strlen(buf); |
| |
| num = 0; |
| for(i = 0; i< test_MAX_pin_num; i++) |
| { |
| |
| if(test_pin_array[i].mbtk_gpio_test_result) |
| { |
| |
| Out_pin = test_pin_array[i].output_pin; |
| in_pin = test_pin_array[i].input_pin; |
| fail_io[num++] = Out_pin; |
| fail_io[num++] = in_pin; |
| |
| } |
| } |
| } |
| |
| else |
| { |
| printf(buf,"ALL GPIO TEST PASS\r\n"); |
| } |
| system("echo 33 > /sys/class/gpio/unexport"); |
| system("echo 120 > /sys/class/gpio/unexport"); |
| system("echo 126 > /sys/class/gpio/unexport"); |
| printf("\n[GPIOTEST] Finished !!\n\n"); |
| return test_fail_count * 2; |
| } |
| |
| #elif defined(MBTK_PROJECT_L508_X6) |
| int gpio_register_test_out_0(int port, int value) |
| { |
| int ret; |
| int i; |
| int valueh = 0; |
| int valuel = 1; |
| |
| printf("Gpio port [%d] test start!\n", port); |
| ret = gpio_register_set_func_0(port); //设功能为GPIO |
| if(ret){ |
| printf("gpio_port can't support!\n"); |
| return -1; |
| } |
| gpio_register_set_direction(port, 1); //设方向为输出 |
| ret = gpio_register_get_value(port); |
| //printf("gpio default value is : %d.\n", ret); |
| |
| |
| //[High] |
| for(i = 0; i <= 10; i++){ |
| gpio_register_set_value(port, 1); |
| usleep(50); |
| valueh = gpio_register_get_value(port); |
| //printf("set high? %d\n",valueh); |
| if(1 == valueh){ |
| break; |
| } |
| } |
| //usleep(10000); |
| for(i = 0; i <= 35; i++){ |
| ret = mbtk_gpio_adc(0); |
| usleep(3000); |
| if(1 == ret){ |
| break; |
| } |
| } |
| //printf("******gpio should is high: %d.******\n", ret); |
| if(1 != ret){ |
| ret=-1; |
| goto exit; |
| } |
| |
| |
| |
| //[Low] |
| usleep(200); |
| for(i = 0; i <= 10; i++){ |
| gpio_register_set_value(port, 0); //输出低 |
| usleep(50); |
| valuel = gpio_register_get_value(port); |
| //printf("set low? %d\n",valuel); |
| if(0 == valuel){ |
| break; |
| } |
| } |
| //usleep(10000); |
| for(i = 0; i <= 35; i++){ |
| ret = mbtk_gpio_adc(0); |
| usleep(3000); |
| if(0 == ret){ |
| break; |
| } |
| } |
| //printf("******gpio should is low: %d.******\n", ret); |
| if(0 != ret){ |
| ret=-1; |
| goto exit; |
| } |
| |
| exit: |
| gpio_register_set_value(port, 0); |
| gpio_register_set_direction(port, 0); //设方向为输入 |
| return ret; |
| } |
| |
| int gpio_register_test_out_1(int port, int value) |
| { |
| int ret; |
| int i; |
| int valueh = 0; |
| int valuel = 1; |
| |
| printf("Gpio port [%d] test start!\n", port); |
| ret = gpio_register_set_func_0(port); //设功能为GPIO |
| if(ret){ |
| printf("gpio_port can't support!\n"); |
| return -1; |
| } |
| gpio_register_set_direction(port, 1); //设方向为输出 |
| ret = gpio_register_get_value(port); |
| printf("gpio default value is : %d.\n", ret); |
| |
| |
| //[High] |
| for(i = 0; i <= 10; i++){ |
| gpio_register_set_value(port, 1); |
| usleep(50); |
| valueh = gpio_register_get_value(port); |
| //printf("set high? %d\n",valueh); |
| if(1 == valueh){ |
| break; |
| } |
| } |
| //usleep(10000); |
| for(i = 0; i <= 35; i++){ |
| ret = mbtk_gpio_adc(1); |
| usleep(3000); |
| if(1 == ret){ |
| break; |
| } |
| } |
| if(1 != ret){ |
| ret=-1; |
| goto exit; |
| } |
| //printf("******gpio should is high: %d.******\n", ret); |
| |
| |
| //[Low] |
| usleep(200); |
| for(i = 0; i <= 10; i++){ |
| gpio_register_set_value(port, 0); //输出低 |
| usleep(50); |
| valuel = gpio_register_get_value(port); |
| //printf("set low? %d\n",valuel); |
| if(0 == valuel){ |
| break; |
| } |
| } |
| //usleep(10000); |
| for(i = 0; i <= 35; i++){ |
| ret = mbtk_gpio_adc(1); |
| usleep(3000); |
| if(0 == ret){ |
| break; |
| } |
| } |
| //printf("******gpio should is low: %d.******\n", ret); |
| if(0 != ret){ |
| ret=-1; |
| goto exit; |
| } |
| |
| exit: |
| gpio_register_set_value(port, 0); |
| gpio_register_set_direction(port, 0); //设方向为输入 |
| return ret; |
| } |
| |
| |
| int gpio_register_test_out_2(int port_in, int port_out, int value) |
| { |
| int ret_in; |
| int ret_out; |
| int i; |
| int valueh = 0; |
| int valuel = 1; |
| |
| printf("Gpio port [%d] test start!\n", port_out); |
| ret_in = gpio_register_set_func_0(port_in); //设功能为GPIO |
| ret_out = gpio_register_set_func_0(port_out); |
| if((ret_in+ret_out)){ |
| printf("gpio_port can't support!\n"); |
| return -1; |
| } |
| gpio_register_set_direction(port_out, 1); //设方向为输出 |
| gpio_register_set_direction(port_in, 0); //设方向为输入 |
| ret_in = gpio_register_get_value(port_in); |
| printf("gpio default value is : %d.\n", ret_in); |
| |
| |
| //[High] |
| for(i = 0; i <= 10; i++){ |
| gpio_register_set_value(port_out, 1); |
| usleep(50); |
| valueh = gpio_register_get_value(port_out); |
| printf("set high? %d\n",valueh); |
| if(1 == valueh){ |
| break; |
| } |
| } |
| |
| |
| for(i = 0; i <= 35; i++){ |
| ret_in = gpio_register_get_value(port_in); |
| usleep(3000); |
| if(1 == ret_in){ |
| break; |
| } |
| } |
| if(1 != ret_in){ |
| ret_in=-1; |
| printf("get high failed! \n"); |
| goto exit; |
| } |
| printf("******gpio should is high: %d.******\n", ret_in); |
| |
| |
| //[Low] |
| usleep(200); |
| for(i = 0; i <= 10; i++){ |
| gpio_register_set_value(port_out, 0); //输出低 |
| usleep(50); |
| valuel = gpio_register_get_value(port_out); |
| printf("set low? %d\n",valuel); |
| if(0 == valuel){ |
| break; |
| } |
| } |
| |
| for(i = 0; i <= 35; i++){ |
| ret_in = gpio_register_get_value(port_in); |
| usleep(3000); |
| if(0 == ret_in){ |
| break; |
| } |
| } |
| printf("******gpio should is low: %d.******\n", ret_in); |
| if(0 != ret_in){ |
| ret_in=-1; |
| printf("get low failed! \n"); |
| goto exit; |
| } |
| |
| exit: |
| gpio_register_set_value(port_out, 0); |
| gpio_register_set_direction(port_out, 0); //设方向为输入 |
| return ret_in; |
| } |
| |
| |
| void gpio_test_init_test_gpio_mode(void ) |
| { |
| |
| |
| int test_gpio_1[] = { |
| 40, 33, 34, 39, 99, |
| 56, 58, 55, 57, 48, 59, 123, 122, 20, 53, |
| 19, 49, 50, 32 ,31, 6, 11, 10, |
| 88, 87, 86, 85, 84, 89, |
| 90, 46, 127, 117, 119, |
| }; |
| |
| int test_gpio_0[] = { |
| 7, 8, 27, 28, 26, 25, 15, 1, 3, 0, |
| 37, 38,35, 36, 42, 41, 21, 22, 24, 23, |
| 54, 125, 18, 13, 14, 17, 16, 5, 4, 2, 12, |
| 44, 45, 47 |
| }; |
| int i, j, ret_0, ret_1, total_1, total_0, n = 0; |
| total_0 = (sizeof(test_gpio_0)/sizeof(int)); |
| total_1 = (sizeof(test_gpio_1)/sizeof(int)); |
| |
| //system("at at+gpsinit=0"); |
| system("i2cset -y -f 2 0x32 0x0d 0x00"); |
| system("i2cset -y -f 2 0x31 0x18 0x8f"); |
| usleep(10000); |
| |
| //printf("[init]gpio_test_init_test_gpio_mode FINISH\n"); |
| /* [1 all gpio set to low] */ |
| for(j = 0; j < 6 ; j++){ |
| for(i = 0; i < total_1; i++){ |
| gpio_register_set_func_0(test_gpio_1[i]); |
| gpio_register_set_direction(test_gpio_1[i], 1); |
| gpio_register_set_value(test_gpio_1[i], 0); |
| } |
| for(i = 0; i < total_0; i++){ |
| gpio_register_set_func_0(test_gpio_0[i]); |
| gpio_register_set_direction(test_gpio_0[i], 1); |
| gpio_register_set_value(test_gpio_0[i], 0); |
| } |
| //usleep(10000); |
| |
| for(i = 0; i <= 35; i++){ |
| ret_0 = mbtk_gpio_adc(0); |
| usleep(3000); |
| ret_1 = mbtk_gpio_adc(1); |
| |
| if(0 == (ret_0 + ret_1)){ |
| break; |
| } |
| } |
| printf("pre set ADC: %d, times: %d\n",(ret_0 + ret_1), j); |
| if(0 == (ret_0 + ret_1)){ |
| break; |
| } |
| } |
| if(0 != (ret_0 + ret_1)){ |
| |
| printf("Fail, please retest"); |
| return -1; |
| } |
| gpio_register_set_value(119, 1); |
| gpio_register_set_value(117, 1); |
| |
| } |
| |
| int mbtk_at_gpio(bool gnss_support, void* arg) |
| { |
| |
| printf("Start test gpio V1.0\n"); |
| int test_gpio_1[] = { |
| 40, 33, 34, 39, 99, |
| 56, 58, 55, 57, 48, 59, 20, 53, |
| 19, 49, 50, 32 ,31, 6, 11, 10,7, |
| 90, 46, 127, |
| 88, 87, 86, 85, 84, 89, |
| }; |
| |
| int test_gpio_0[] = { |
| 35, 36, 42, 41, 21, 22, 24, 23, |
| 54, 125, 18, 13, 14, 17, 16, 5, 4, 2, 12,0, |
| 27, 28, 26, 25, 15, 1, 3, |
| 37, 38,8 |
| }; |
| int test_gpio_2[] = { //GPS组 |
| 43,47, |
| //45,44 |
| }; |
| |
| int i, j, ret_0, ret_1, ret_2, total_1, total_0, total_2, n = 0; |
| int *fail_io = (int *)arg; |
| total_0 = (sizeof(test_gpio_0)/sizeof(int)); |
| total_1 = (sizeof(test_gpio_1)/sizeof(int)); |
| total_2 = (sizeof(test_gpio_2)/sizeof(int)); |
| |
| /* [1 all gpio Init] */ |
| gpio_test_init_test_gpio_mode(); |
| |
| |
| /* [2 GPIOTEST] */ |
| //Test 0 |
| for(i = 0; i < total_0; i++){ |
| ret_0 = gpio_register_test_out_0(test_gpio_0[i], 0); |
| if(-1 == ret_0){ |
| printf("!!!!!!!!!!!!gpio [%d] test failed!!!!!!!!!!!!\n", test_gpio_0[i]); |
| fail_io[n] = test_gpio_0[i]; |
| n++; |
| }else{ |
| //printf("############gpio [%d] test success############\n", test_gpio_0[i]); |
| } |
| } |
| |
| //Test 1 |
| for(i = 0; i < total_1; i++){ |
| ret_1 = gpio_register_test_out_1(test_gpio_1[i], 0); |
| if(-1 == ret_1){ |
| printf("!!!!!!!!!!!!gpio [%d] test failed!!!!!!!!!!!!\n", test_gpio_1[i]); |
| fail_io[n] = test_gpio_1[i]; |
| n++; |
| }else{ |
| //printf("############gpio [%d] test success############\n", test_gpio_1[i]); |
| } |
| } |
| |
| //Test 2 |
| for(i = 0; i < total_2; i=i+2){ |
| ret_2 = gpio_register_test_out_2(test_gpio_2[i], test_gpio_2[i+1], 0); |
| if(-1 == ret_2){ |
| //printf("!!!!!!!!!!!!gpio [%d] test failed!!!!!!!!!!!!\n", test_gpio_2[i+1]); |
| fail_io[n] = test_gpio_2[i]; |
| n++; |
| }else{ |
| printf("############gpio [%d] test success############\n", test_gpio_2[i+1]); |
| } |
| } |
| |
| mbtk_adc_close(); |
| return n; |
| } |
| |
| #elif 0//(MBTK_PROJECT_T108) |
| int gpio_register_test_out(int port, int value) |
| { |
| int ret; |
| int i; |
| int valueh = 0; |
| int valuel = 1; |
| |
| //printf("Gpio port [%d] test start!\n", port); |
| ret = gpio_register_set_func_0(port); //设功能为GPIO |
| if(ret){ |
| printf("gpio_port can't support!\n"); |
| return -1; |
| } |
| gpio_register_set_direction(port, 1); //设方向为输出 |
| //ret = gpio_register_get_value(port); |
| //printf("gpio default value is: %d\n", ret); |
| |
| |
| //[High] |
| for(i = 0; i <= 9; i++){ |
| gpio_register_set_value(port, 1); |
| usleep(50); |
| //valueh = gpio_register_get_value(port); |
| //printf("set high? %d\n", valueh); |
| if(1 == valueh){ |
| break; |
| } |
| } |
| |
| for(i = 0; i <= 35; i++){ |
| ret = gpio_register_get_value(118); |
| if(1 == ret){ |
| break; |
| } |
| usleep(3000); |
| } |
| printf("******gpio should is high: %d.******\n", ret); |
| if(1 != ret){ |
| ret=-1; |
| goto exit; |
| } |
| |
| //[Low] |
| usleep(200); |
| for(i = 0; i <= 9; i++){ |
| gpio_register_set_value(port, 0); //输出低 |
| usleep(50); |
| //valuel = gpio_register_get_value(port); |
| //printf("set low? %d\n", valuel); |
| if(0 == valuel){ |
| break; |
| } |
| } |
| |
| for(i = 0; i <= 35; i++){ |
| ret = gpio_register_get_value(118); |
| if(0 == ret){ |
| break; |
| } |
| usleep(3000); |
| } |
| //printf("******gpio should is low: %d.******\n", ret); |
| if(0 != ret){ |
| ret=-1; |
| goto exit; |
| } |
| |
| exit: |
| gpio_register_set_value(port, 0); |
| gpio_register_set_direction(port, 0); //设方向为输入 |
| return ret; |
| } |
| |
| int gpio_test_init_test_gpio_mode(void) |
| { |
| const int test_gpio[] = { |
| 99, |
| 117, |
| 21,22,23,24,44,41,120, |
| 8,127,46,59,58,57,56,55,48,19,34,33,35,36,49, |
| 50,25,28,26,122,20,10,11, |
| 39,40,37,38, |
| 51,52,31,32, |
| }; |
| |
| int i, j, ret, total, n = 0; |
| total = (sizeof(test_gpio)/sizeof(int)); |
| printf("[init]gpio_test_init_test_gpio_mode BEGIN\n"); |
| |
| /* [1 all gpio set to low] */ |
| gpio_register_set_func_0(118); |
| gpio_register_set_direction(118, 0); |
| system("echo in > /sys/class/gpio/gpio118/direction"); |
| |
| for(j = 0; j < 6 ; j++){ |
| for(i = 0; i < total; i++){ |
| gpio_register_set_func_0(test_gpio[i]); |
| gpio_register_set_direction(test_gpio[i], 1); |
| gpio_register_set_value(test_gpio[i], 0); |
| //ret = gpio_register_get_value(test_gpio[i]); |
| //printf("[init]get gpio%d=%d\n", test_gpio[i], ret); |
| } |
| |
| for(i = 0; i <= 35; i++){ |
| ret = gpio_register_get_value(118); |
| printf("[init]get gpi118=%d\n", ret); |
| usleep(3000); |
| if(0 == (ret)){ |
| break; |
| } |
| } |
| |
| printf("pre set ADC: %d, times: %d\n",(ret), j); |
| if(0 == (ret)){ |
| break; |
| } |
| } |
| if(0 != (ret)){ |
| printf("!!!Set all low FAIL, please retest\n"); |
| return -1; |
| } |
| return 0; |
| } |
| |
| int mbtk_at_gpio(bool gnss_support, void* arg) |
| { |
| |
| const int test_gpio[] = { |
| //GPIO PIN GPIO PIN GPIO PIN GPIO PIN |
| 99, 170, 117, 59, 21, 61, 22, 62, |
| 23, 144, 24, 147, 44, 5, 41, 159, |
| 120, 143, 8, 171, 127, 160, 46, 149, |
| 59, 19, 58, 18, 57, 20, 56, 21, |
| 55, 22, 48, 23, 19, 3, 34, 79, |
| 33, 80, 35, 78, 36, 77, 49, 43, |
| 50, 42, 25, 67, 28, 66, 26, 65, |
| 122, 169, 20, 152, 10, 74, 11, 73, |
| 39, 166, 40, 164, 37, 165, 38, 163, |
| 51, 58, 52, 60, 31, 57, 32, 56, |
| }; |
| |
| int i, n = 0, ret, total; |
| int *fail_io = (int *)arg; |
| int try_count = 0; |
| total = (sizeof(test_gpio)/sizeof(int)); |
| printf("T108 Start test gpio V1.0, total gpio=%d\n", (total/2)); |
| |
| for(try_count; try_count < 4; try_count++){ |
| n = 0; |
| /* [1 all gpio Init] */ |
| gpio_test_init_test_gpio_mode(); |
| |
| /* [2 GPIOTEST] */ |
| for(i = 0; i < total; i = i + 2){ |
| ret = gpio_register_test_out(test_gpio[i], 0); |
| if(-1 == ret){ |
| n++; |
| printf("!!!!!!!!!!!!gpio [%d] test failed!!!!!!!!!!!!\n", test_gpio[i]); |
| if(try_count != 3){ |
| printf(" ---TEST FAILED! RETRY!--- \n"); |
| usleep(5000); |
| break; |
| } |
| fail_io[n - 1] = test_gpio[i+1]; |
| }else{ |
| //printf("############gpio [%d] test success############\n", test_gpio[i]); |
| } |
| } |
| if(0 == n){ |
| break; |
| } |
| } |
| return n; |
| } |
| |
| |
| #elif (MBTK_PROJECT_T108) |
| static int gpio_test(int port) |
| { |
| int ret; |
| int i; |
| int valueh = 0; |
| int valuel = 1; |
| |
| //printf("Gpio port [%d] test start!\n", port); |
| ret = gpio_register_set_func_0(port); |
| if(ret){ |
| printf("gpio_port can't support!\n"); |
| return -1; |
| } |
| gpio_register_set_direction(port, 1); |
| //ret = gpio_register_get_value(port); |
| //printf("gpio default value is: %d\n", ret); |
| |
| |
| //[High] |
| for(i = 0; i <= 5; i++){ |
| gpio_register_set_value(port, 1); |
| usleep(50); |
| //valueh = gpio_register_get_value(port); |
| //printf("set high? %d\n", valueh); |
| if(1 == valueh){ |
| break; |
| } |
| } |
| |
| for(i = 0; i <= 5; i++){ |
| ret = gpio_register_get_value(118); |
| if(1 == ret){ |
| |
| break; |
| } |
| usleep(3000); |
| } |
| //printf("count=%d \n", i); |
| //printf("******gpio should is high: %d.******\n", ret); |
| if(1 != ret){ |
| ret=-1; |
| goto exit; |
| } |
| |
| //[Low] |
| usleep(200); |
| for(i = 0; i <= 9; i++){ |
| gpio_register_set_value(port, 0); |
| usleep(50); |
| //valuel = gpio_register_get_value(port); |
| //printf("set low? %d\n", valuel); |
| if(0 == valuel){ |
| break; |
| } |
| } |
| |
| for(i = 0; i <= 5; i++){ |
| ret = gpio_register_get_value(118); |
| if(0 == ret){ |
| |
| break; |
| } |
| usleep(3000); |
| } |
| //printf("count=%d \n", i); |
| //printf("******gpio should is low: %d.******\n", ret); |
| if(0 != ret){ |
| ret=-1; |
| goto exit; |
| } |
| |
| exit: |
| gpio_register_set_value(port, 0); |
| gpio_register_set_direction(port, 0); |
| return ret; |
| |
| } |
| |
| static int gpio_test_init_test_gpio_mode(void) |
| { |
| const int test_gpio[] = { |
| 99,8,117,21,22,23,24,41,120,19,123, |
| 58,59,57,56,55,48,125,127,36,35,34, |
| 33,54,47,53,46,50,49,11,10,26,28,25, |
| 27,32,31,51,52,39,40,37,38, |
| 44,45 |
| }; |
| |
| int i, j, ret, total, n = 0; |
| total = (sizeof(test_gpio)/sizeof(int)); |
| //printf("[init]gpio_test_init_test_gpio_mode BEGIN\n"); |
| |
| /* [1 all gpio set to low] */ |
| gpio_register_set_func_0(118); |
| gpio_register_set_direction(118, 0); |
| |
| for(j = 0; j < 5 ; j++){ |
| for(i = 0; i < total; i++){ |
| gpio_register_set_func_0(test_gpio[i]); |
| gpio_register_set_direction(test_gpio[i], 1); |
| gpio_register_set_value(test_gpio[i], 0); |
| //ret = gpio_register_get_value(test_gpio[i]); |
| //printf("[init]get gpio%d=%d\n", test_gpio[i], ret); |
| } |
| |
| |
| for(i = 0; i <= 10; i++){ |
| ret = gpio_register_get_value(118); |
| //printf("[init]get gpi118=%d\n", ret); |
| usleep(3000); |
| if(0 == (ret)){ |
| break; |
| } |
| } |
| |
| //printf("pre set 118: %d, times: %d\n",(ret), j); |
| if(0 == (ret)){ |
| break; |
| } |
| } |
| if(0 != (ret)){ |
| printf("!!!Set all low FAIL, please retest\n"); |
| return -1; |
| } |
| return 0; |
| } |
| |
| int mbtk_at_gpio(bool gnss_support, void* arg) |
| { |
| const int test_gpio[] = { |
| //GPIO PIN GPIO PIN GPIO PIN GPIO PIN |
| 99, 170, 8, 171, 117, 59, 21, 61, |
| 22, 62, 23, 144, 24, 147, 41, 159, |
| 120, 143, 19, 3, 123, 5, 58, 18, |
| 59, 19, 57, 20, 56, 21, 55, 22, |
| 48, 23, 125, 149, 127, 160, 36, 77, |
| 35, 78, 34, 79, 33, 80, 54, 163, |
| #if 0 //Hard Ware ERROR! |
| 47, 164, |
| 46, 166, |
| #endif |
| 53, 165, 50, 42, 49, 43, 11, 73, |
| 10, 74, 26, 65, 28, 66, 25, 67, |
| 27, 68, 32, 56, 31, 57, 51, 58, |
| 52, 60, 39, 192, 40, 193, 37, 194, |
| 38, 195, |
| #if 0 //undefine GNSS |
| 44, 161, |
| 45, 151, |
| #endif |
| }; |
| |
| int i, n = 0, ret, total; |
| int *fail_io = (int *)arg; |
| int try_count; |
| total = (sizeof(test_gpio)/sizeof(int)); |
| printf("T108 V2 Start test gpio V0.8, total gpio=%d\n", (total/2)); |
| |
| for(try_count = 0; try_count < 4; try_count++){ |
| n = 0; |
| /* [1 all gpio Init] */ |
| gpio_test_init_test_gpio_mode(); |
| |
| /* [2 GPIOTEST] */ |
| for(i = 0; i < total; i = i + 2){ |
| ret = gpio_test(test_gpio[i]); |
| if(-1 == ret){ |
| n++; |
| printf("!!!!!!!!!!!!gpio [%d] test failed!!!!!!!!!!!!\n", test_gpio[i]); |
| if(try_count != 3){ |
| printf(" ---TEST FAILED! RETRY!--- \n"); |
| usleep(5000); |
| break; |
| } |
| fail_io[n - 1] = test_gpio[i + 1]; |
| }else{ |
| //printf("############gpio [%d] test success############\n", test_gpio[i]); |
| } |
| } |
| if(0 == n){ |
| printf(" ---ALL PASS---\n"); |
| break; |
| } |
| } |
| return n; |
| } |
| |
| |
| #else |
| int mbtk_at_gpio(bool gnss_support, void* arg) |
| { |
| return -1; |
| } |
| |
| #endif |