| /***************************************************************************** |
| * Copyright Statement: |
| * -------------------- |
| * This software is protected by Copyright and the information contained |
| * herein is confidential. The software may not be copied and the information |
| * contained herein may not be used or disclosed except with the written |
| * permission of MediaTek Inc. (C) 2012 |
| * |
| * BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES |
| * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE") |
| * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON |
| * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT. |
| * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE |
| * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR |
| * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH |
| * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO |
| * NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S |
| * SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM. |
| * |
| * BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE |
| * LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE, |
| * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE, |
| * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO |
| * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. |
| * |
| * THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE |
| * WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF |
| * LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND |
| * RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER |
| * THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC). |
| * |
| *****************************************************************************/ |
| |
| /******************************************************************************* |
| * Filename: |
| * --------- |
| * drv_gpio.c |
| * |
| * Project: |
| * -------- |
| * TATAKA |
| * |
| * Description: |
| * ------------ |
| * Low level GPIO driver |
| * |
| * Author: |
| * ------- |
| * ------- |
| * |
| * ========================================================================== |
| * $Log$ |
| * |
| * 05 06 2022 yao.xue |
| * [MOLY00851720] [FM350][MIPI][IO_Driving][clock speed][zontn.wang]The MIPI IO Driving strength and clock speed setting |
| * modify GPIO IOCFG regbase. |
| * |
| * 11 16 2020 zhiqiang.yu |
| * [MOLY00595491] [Colgin]MD GPIO DRV Patchback From T700 Branch |
| * |
| * . |
| * |
| * 11 11 2020 zhiqiang.yu |
| * [MOLY00593568] [MT6877]Call For Check In MD GPIO Drv |
| * |
| * . |
| * |
| * 07 16 2020 zhiqiang.yu |
| * [MOLY00546611] [MT6833]Call For Check In MD GPIO Driver |
| * |
| * . |
| * |
| * 01 21 2020 zhiqiang.yu |
| * [MOLY00476172] [MT6853]Call For Check In GPIO Drv |
| * |
| * . |
| * |
| * 12 04 2019 zhiqiang.yu |
| * [MOLY00463572] [MMRF] Ddie driving customization development |
| * |
| * .GPIO DRIVER |
| * |
| * 09 24 2019 zhiqiang.yu |
| * [MOLY00443103] [MT6873]Check in md gpio driver |
| * |
| * . |
| * |
| * 06 18 2019 zhiqiang.yu |
| * [MOLY00413533] [MT6297]Fix GPIO Drv build Warning about LTO |
| * |
| * . |
| * |
| * 12 07 2018 zhiqiang.yu |
| * [MOLY00371362] [Pertus]check in gpio drv |
| * |
| * .fix build error |
| * |
| * 08 21 2018 zhiqiang.yu |
| * [MOLY00347417] [MT6297][VMOLY]check in md gpio&eint drv |
| * |
| * .fix build error |
| * |
| * 08 02 2018 zhiqiang.yu |
| * [MOLY00343825] [MT6779]Call For Check In,gpio driver |
| * |
| * . |
| * |
| * 04 03 2018 zhiqiang.yu |
| * remove ownership@6290. |
| * |
| * 12 18 2017 zhiqiang.yu |
| * [MOLY00296840] [EIGER]call for mt3967 gpio driver |
| * |
| * . |
| * |
| * 11 01 2017 zhiqiang.yu |
| * [MOLY00244517] [MT6295M]fix build error,for gpio driver.patch back from LR12A.MP2.MT6295M.DEV. |
| * |
| * 10 30 2017 zhiqiang.yu |
| * [MOLY00286048] [MT6765]check in gpio drv for MT6765. |
| * |
| * 08 24 2017 zhiqiang.yu |
| * [MOLY00273500] [MT6771]check in md gpio driver |
| * |
| * . |
| * |
| * 06 12 2017 zhiqiang.yu |
| * [MOLY00244007] [MT6739]check in gpio driver for zion |
| * |
| * . |
| * |
| * 11 16 2016 zhiqiang.yu |
| * [MOLY00213576] [MT6763]eint&gpio driver check in. |
| * |
| * 02 22 2016 zhiqiang.yu |
| * [MOLY00165689] Code Inspection and MSBB Scan |
| * Fix high impact defect. |
| * |
| * 08 04 2015 zhiqiang.yu |
| * [MOLY00135213] check in gpiodriver code for mt6797 project |
| * . |
| * |
| * 07 22 2015 zhiqiang.yu |
| * [MOLY00131033] enable sp set gpio mode funtion |
| * <saved by Perforce> |
| * |
| * 06 17 2015 zhiqiang.yu |
| * [MOLY00121904] checkin md eint code for mt6755 |
| * . |
| * |
| * 06 16 2015 zhiqiang.yu |
| * [MOLY00121625] checkin md gpio code for mt6755 |
| * . |
| * |
| * 06 30 2014 chuanbo.liao |
| * [MOLY00070787] [tk6291]fix 6291 build error |
| * [6291]modify the EINT/GPIO base address |
| * |
| * 05 10 2013 da.wang |
| * [MOLY00022149] [MT6290E1][TRUNK] Add GPIO driver API for Meta mode solution |
| * Upload GPIO driver API for meta mode. |
| * |
| * 02 04 2013 da.wang |
| * [MOLY00009904] [GPIO/EINT] Rename MT7280 to MT6290 on MOLY trunk |
| * .rename GPIO/EINT related keywords MT7208 to MT6290 in MOLY |
| ****************************************************************************/ |
| #include "drv_comm.h" |
| #include "drv_gpio.h" |
| #include "kal_general_types.h" |
| #include "devdrv_ls.h" |
| |
| |
| //======================================================================== |
| // Global variable |
| //======================================================================== |
| |
| #ifdef __CUST_NEW__ |
| #if defined(DRV_GPIO_8_MODES) || defined(DRV_GPIO_MODE_4BITS) |
| extern const kal_uint32 gpio_mode_allowed[][8]; |
| #else //defined(DRV_GPIO_8_MODES) || defined(DRV_GPIO_MODE_4BITS) |
| extern const kal_uint32 gpio_mode_allowed[][4]; |
| #endif //defined(DRV_GPIO_8_MODES) || defined(DRV_GPIO_MODE_4BITS) |
| extern const kal_uint32 gpio_dir_out_allowed[]; |
| extern const kal_uint32 gpio_dir_in_allowed[]; |
| extern const kal_uint16 gpo_mode_allowed[]; |
| extern kal_uint32 gpio_check_for_write[]; |
| extern kal_uint32 gpio_check_for_read[]; |
| extern kal_uint16 gpo_check_for_write[]; |
| extern kal_bool gpio_debug_enable; |
| #endif /* __CUST_NEW__ */ |
| |
| #if 0 |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| /* under construction !*/ |
| #endif |
| |
| //======================================================================== |
| /** |
| * @brief get direction register value of pin |
| * @param gpio_pin : The GPIO pin to be read. |
| * @return return the direction register value of gpio_pin |
| * 0: the direction of gpio is input |
| * 1: the direction of gpio is output |
| * GPIO_FAIL: gpio_pin is out of range |
| */ |
| kal_int32 gpio_get_dir_value (gpio_pin_e gpio_pin) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| unsigned long pos; |
| unsigned long bit; |
| unsigned long data; |
| |
| if (gpio_pin>GPIO_PIN_MAX) |
| { |
| GPIO_ERR("The gpio pin is out of range of MAX num (%d) !!!!", GPIO_PIN_MAX); |
| return GPIO_FAIL; |
| } |
| |
| pos = gpio_pin/32; |
| bit = gpio_pin%32; |
| |
| data = DRV_Reg32((GPIO_DIR1 + pos*0x10)); |
| |
| return ((data&(1<<bit))?1:0); |
| |
| #endif |
| } |
| |
| // ---------------------------------------------------------- |
| /** |
| * @brief Set GPIO_DIR input or output |
| * @param gpio_pin : The GPIO pin to be set. |
| * @param direction : The direction to be set in gpio_pin. |
| * 1: set as output pin |
| * 0: set as input pin |
| * @return GPIO_OK : set successful, GPIO_FAIL : set failed |
| */ |
| static kal_int32 _GPIO_Set_Direction(gpio_pin_e gpio_pin, kal_uint32 direction) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| unsigned long pos; |
| unsigned long bit; |
| //unsigned long data; |
| |
| if (gpio_pin>GPIO_PIN_MAX) |
| { |
| GPIO_ERR("The gpio pin is out of range of MAX num (%d) !!!!", GPIO_PIN_MAX); |
| return GPIO_FAIL; |
| } |
| |
| pos = gpio_pin/32; |
| bit = gpio_pin%32; |
| if (direction == GPIO_AS_OUTPUT) |
| DRV_WriteReg32(GPIO_DIR_SET(pos),1<<bit); |
| else |
| DRV_WriteReg32(GPIO_DIR_CLR(pos),1<<bit); |
| |
| return GPIO_OK; |
| |
| #endif |
| } |
| |
| |
| |
| //======================================================================== |
| /*-----------------------------------------------------------------------* |
| * @brief Read the input value of the gpio pin. |
| * @param gpio_pin : The pin which to read value. |
| * @param *value : The variable to save value read from the pin, will be 0 or 1. |
| * @return GPIO_OK : get successful, GPIO_FAIL : get failed |
| *-----------------------------------------------------------------------*/ |
| kal_int32 GPIO_READ_INPUT_VALUE (gpio_pin_e gpio_pin, kal_uint32 *value) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| unsigned long pos; |
| unsigned long bit; |
| unsigned long data; |
| |
| if (gpio_pin>GPIO_PIN_MAX) |
| { |
| GPIO_ERR("The gpio pin is out of range of MAX num (%d) !!!!", GPIO_PIN_MAX); |
| return GPIO_FAIL; |
| } |
| |
| pos = gpio_pin/32; |
| bit = gpio_pin%32; |
| data = DRV_Reg32((GPIO_DIN1 + pos*0x10)); |
| *value=((data&(1<<bit))?1:0); |
| |
| return GPIO_OK; |
| |
| #endif |
| } |
| |
| |
| |
| |
| // ---------------------------------------------------------- |
| /** |
| * @brief Enable or Disable GPIO_PULLEN specific pin |
| * @param gpio_pin : The GPIO pin to be set. |
| * @param pullen : set 1 to enable pull up/down in gpio_pin. |
| * @return GPIO_OK : set successful, GPIO_FAIL : set failed |
| */ |
| kal_int32 _GPIO_Set_Pullen(gpio_pin_e gpio_pin, kal_uint32 pullen) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| return GPIO_FAIL; |
| #else |
| return GPIO_FAIL; |
| #endif |
| } |
| |
| // ---------------------------------------------------------- |
| /** |
| * @brief Set GPIO_PULLSEL to pull-up or pull-down |
| * @param gpio_pin : The GPIO pin to be set. |
| * @param updown : set GPIO_PULL_UP to set gpio_pin in pull-up. set GPIO_PULL_DOWN to set gpio_pin pull_down. |
| * @return GPIO_OK : set successful, GPIO_FAIL : set failed |
| */ |
| kal_int32 _GPIO_Set_Pullsel(gpio_pin_e gpio_pin, kal_uint32 updown) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| return GPIO_FAIL; |
| #else |
| return GPIO_FAIL; |
| #endif |
| } |
| |
| |
| /** |
| * @brief Set pin direction as an output pin. |
| * @param gpio_pin : The pin which to be set direction to output pin. |
| * @return GPIO_OK : set successful, GPIO_FAIL : set failed |
| */ |
| kal_int32 GPIO_SET_DIRECT_OUTPUT (gpio_pin_e gpio_pin) |
| { |
| if (gpio_pin>GPIO_PIN_MAX) |
| { |
| GPIO_ERR("The gpio pin is out of range of MAX num (%d) !!!!", GPIO_PIN_MAX); |
| return GPIO_FAIL; |
| } |
| |
| if (GPIO_FAIL == _GPIO_Set_Pullen(gpio_pin, GPIO_DISABLE) ) |
| { return GPIO_FAIL; } |
| |
| if (GPIO_FAIL == _GPIO_Set_Direction(gpio_pin, GPIO_AS_OUTPUT) ) |
| { return GPIO_FAIL; } |
| |
| return GPIO_OK; |
| } |
| |
| //======================================================================== |
| /** |
| * @brief Set pin direction as an input pin. |
| * @param gpio_pin : The pin which want to be set. |
| * @param pull_en : GPIO_ENABLE or GPIO_DISABLE, Set if pull-up/down function is enable. |
| * @param pull_updown : GPIO_PULL_UP / GPIO_PULL_DOWN, it works only when pull_en is enable. |
| * @return GPIO_OK : set successful, GPIO_FAIL : set failed |
| */ |
| kal_int32 GPIO_SET_DIRECT_INPUT (gpio_pin_e gpio_pin, kal_uint32 pull_en, kal_uint32 pull_updown) |
| { |
| if (gpio_pin>GPIO_PIN_MAX) |
| { |
| GPIO_ERR("The gpio pin is out of range of MAX num (%d) !!!!", GPIO_PIN_MAX); |
| return GPIO_FAIL; |
| } |
| /* Step-1 Check GPIO_Mode to make sure the pin can be uesed as GPIO*/ |
| //_GPIO_ShareMode_Chk(gpio_pin); |
| |
| /* Step-2 set the pull-up/down */ |
| // When input, the pullen could be set as required |
| // If the pullen is set, the pullsel should be set. |
| if (GPIO_FAIL == _GPIO_Set_Pullen(gpio_pin, pull_en) ) |
| { return GPIO_FAIL; } |
| |
| /* Step-3 set the pull-up/down when gpio is input*/ |
| if (GPIO_FAIL == _GPIO_Set_Pullsel(gpio_pin, pull_updown) ) |
| { return GPIO_FAIL; } |
| |
| /* Step-4 set the direction to input*/ |
| if (GPIO_FAIL == _GPIO_Set_Direction(gpio_pin, GPIO_AS_INPUT) ) |
| { return GPIO_FAIL; } |
| |
| |
| return GPIO_OK; |
| } |
| |
| |
| //======================================================================== |
| /** |
| * @brief set the data inversion parameter of the gpio pin. |
| * @param gpio_pin : The pin which is to be set data inversion. |
| * @param inversion: The value to be set, will be 0 or 1. |
| * 0: disable data inversion |
| 1: enable data inversion |
| * @return GPIO_OK : set successful, GPIO_FAIL : set failed |
| */ |
| kal_int32 gpio_set_data_inversion(gpio_pin_e gpio_pin, kal_uint32 inversion) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| return GPIO_FAIL; |
| #else |
| return GPIO_FAIL; |
| #endif |
| } |
| |
| |
| |
| //======================================================================== |
| /** |
| * @brief Write the output value of the gpio pin. It only work when the pin is an output pin. |
| * @param gpio_pin : The pin which to be set output value. |
| * @param value : The value which want to be set, can be 0 or 1. |
| * @return GPIO_OK : set successful, GPIO_FAIL : set failed |
| */ |
| kal_int32 GPIO_WRITE_OUTPUT_VALUE (gpio_pin_e gpio_pin, kal_uint32 value) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| unsigned long pos; |
| unsigned long bit; |
| //unsigned long data; |
| |
| if (gpio_pin>GPIO_PIN_MAX) |
| { |
| GPIO_ERR("The gpio pin is out of range of MAX num (%d) !!!!", GPIO_PIN_MAX); |
| return GPIO_FAIL; |
| } |
| |
| pos = gpio_pin/32; |
| bit = gpio_pin%32; |
| if (value == GPIO_OUTPUT_HIGH) |
| DRV_WriteReg32(GPIO_DOUT_SET(pos),1<<bit); |
| else |
| DRV_WriteReg32(GPIO_DOUT_CLR(pos),1<<bit); |
| |
| return GPIO_OK; |
| #endif |
| } |
| |
| |
| /*-----------------------------------------------------------------------* |
| * FUNCTION |
| * GPIO_ReadIO |
| * |
| * DESCRIPTION |
| * This function is to read data from one GPIO pin |
| * |
| * CALLS |
| * Read data from one GPIO pin |
| * |
| * PARAMETERS |
| * port: pin number |
| * |
| * RETURNS |
| * 1 or 0 |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| *-----------------------------------------------------------------------*/ |
| char GPIO_ReadIO(kal_int16 port) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| kal_uint32 input_val = 0; |
| if(GPIO_READ_INPUT_VALUE((gpio_pin_e)port, &input_val) != GPIO_OK) |
| { |
| GPIO_ERR("\tGPIO_ReadIO: read the value of port[%d] failed!! ",port); |
| } |
| return (char)input_val; |
| #endif |
| } |
| |
| |
| /* |
| * FUNCTION |
| * GPIO_WriteIO |
| * |
| * DESCRIPTION |
| * This function is to write data to one GPIO port |
| * |
| * CALLS |
| * Write data to one GPIO port |
| * |
| * PARAMETERS |
| * data: KAL_TRUE(1) or KAL_FALSE(0) |
| * port: gpio pin number |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| */ |
| void GPIO_WriteIO(char data, kal_int16 port) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| GPIO_WRITE_OUTPUT_VALUE((gpio_pin_e)port,data); |
| #endif |
| } |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| #define MAX_GPIO_MODE_PER_REG 8 |
| #define GPIO_MODE_BITS 4 |
| #endif |
| void GPIO_ModeSetup(kal_uint16 pin, kal_uint16 conf_data) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| #if defined(__FPGA__) && defined(MT6295M) |
| |
| #else |
| unsigned long pos; |
| unsigned long bit; |
| unsigned long data; |
| unsigned long mask = (1L << GPIO_MODE_BITS)-1; |
| unsigned long offset; |
| |
| pos = pin/MAX_GPIO_MODE_PER_REG; |
| bit = pin%MAX_GPIO_MODE_PER_REG; |
| |
| offset = GPIO_MODE_BITS*bit; |
| |
| data = DRV_Reg32(GPIO_MODE(pos)); |
| data &= ~(mask << offset); |
| data |= (conf_data << offset); |
| //to avoid possible race condition with AP,use SET/CLR reg to setup MODE register |
| DRV_WriteReg32(GPIO_MODE_CLR(pos),(mask << (GPIO_MODE_BITS*bit))); |
| DRV_WriteReg32(GPIO_MODE_SET(pos),data); |
| #endif |
| #endif |
| } |
| |
| /* |
| * FUNCTION |
| * GPIO_InitIO |
| * |
| * DESCRIPTION |
| * This function is to initialize one GPIO pin as INPUT or OUTPUT |
| * |
| * CALLS |
| * Initialize one GPIO pin as INPUT or OUTPUT |
| * |
| * PARAMETERS |
| * direction: INPUT or OUTPUT |
| * port: pin number |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| */ |
| void GPIO_InitIO(char direction, kal_int16 port) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| if(GPIO_OUTPUT == direction) |
| { |
| _GPIO_Set_Direction((gpio_pin_e)port,GPIO_OUTPUT); |
| } |
| else |
| { |
| _GPIO_Set_Direction((gpio_pin_e)port,GPIO_INPUT); |
| } |
| |
| #endif |
| } |
| |
| char GPIO_ReturnMode(kal_int16 port) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| #if defined(__FPGA__) && defined(MT6295M) |
| return GPIO_FAIL; |
| #else |
| unsigned long pos; |
| unsigned long bit; |
| unsigned long data; |
| unsigned long mask = (1L << GPIO_MODE_BITS)-1; |
| unsigned long offset; |
| |
| pos = port/MAX_GPIO_MODE_PER_REG; |
| bit = port%MAX_GPIO_MODE_PER_REG; |
| |
| offset = GPIO_MODE_BITS*bit; |
| |
| data = DRV_Reg32(GPIO_MODE(pos)); |
| data = (data >> offset)&mask; |
| return (char)data; |
| #endif |
| #else |
| return GPIO_FAIL; |
| #endif |
| } |
| |
| /* |
| * FUNCTION |
| * GPIO_ReturnDir |
| * |
| * DESCRIPTION |
| * This function is to report GPIO direction value |
| * |
| * CALLS |
| * Report GPIO direction value accoding to input pin |
| * |
| * PARAMETERS |
| * GPIO pin |
| * |
| * RETURNS |
| * GPIO direction value |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| */ |
| char GPIO_ReturnDir(kal_int16 port) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| return gpio_get_dir_value(port); |
| #endif |
| } |
| |
| /* |
| * FUNCTION |
| * GPIO_ReturnDout |
| * |
| * DESCRIPTION |
| * This function is to report GPIO output value |
| * |
| * CALLS |
| * Report GPIO output value accoding to input pin |
| * |
| * PARAMETERS |
| * GPIO pin |
| * |
| * RETURNS |
| * GPIO output value |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| */ |
| char GPIO_ReturnDout(kal_int16 port) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| return GPIO_FAIL; |
| #endif |
| } |
| |
| |
| /* |
| * FUNCTION |
| * GPIO_PullenSetup |
| * |
| * DESCRIPTION |
| * This function is to enable or disable the pull up/down of the related GPIO pin. |
| * You can not decide to pull up or down, it is set inside the chip. |
| * And, the setting is different from pin by pin. |
| * |
| * PARAMETERS |
| * pin : gpio pin number range from 0~63 |
| * enable: enable the pull up/down |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * |
| */ |
| void GPIO_PullenSetup(kal_uint16 pin, kal_bool enable) |
| { |
| #ifdef __CUST_NEW__ |
| pin &= (~GPIO_MAGIC_NUM); |
| #endif |
| _GPIO_Set_Pullen(pin,enable); |
| } |
| |
| /* |
| * FUNCTION |
| * GPIO_PullSelSetup |
| * |
| * DESCRIPTION |
| * This function is to select pull up/down of the related GPIO pin. |
| * |
| * PARAMETERS |
| * pin : gpio pin number range from 0~63 |
| * enable: enable the pull up/down |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * |
| */ |
| void GPIO_PullSelSetup(kal_uint16 pin, kal_bool pull_up) |
| { |
| #ifdef __CUST_NEW__ |
| pin &= (~GPIO_MAGIC_NUM); |
| #endif |
| _GPIO_Set_Pullsel(pin,pull_up); |
| } |
| |
| /* |
| * FUNCTION |
| * GPIO_DinvSetup |
| * |
| * DESCRIPTION |
| * This function is to enable data invert of the related GPIO pin |
| * |
| * PARAMETERS |
| * pin : gpio pin number range from 0~63 |
| * enable: enable the data inversion |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * |
| */ |
| void GPIO_DinvSetup(kal_uint16 pin, kal_bool enable) |
| { |
| #ifdef __CUST_NEW__ |
| pin &= (~GPIO_MAGIC_NUM); |
| #endif |
| gpio_set_data_inversion(pin,enable); |
| } |
| |
| /* |
| * FUNCTION |
| * GPIO_SetDebugMode |
| * |
| * DESCRIPTION |
| * This function is to set GPIO HW debug mode |
| * currently MT6290 not support this function |
| * |
| * CALLS |
| * set GPIO HW debug mode |
| * |
| * PARAMETERS |
| * enable - KAL_TRUE: turn on the debug mode |
| * KAL_FALSE: turn off the debug mode |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| */ |
| void GPIO_SetDebugMode(kal_bool enable) |
| { |
| //not support in MT6290 |
| } |
| |
| #ifdef __CUST_NEW__ |
| |
| /* |
| * FUNCTION |
| * GPIO_InitIO_FAST |
| * |
| * DESCRIPTION |
| * This function is to initialize one GPIO pin as INPUT or OUTPUT. |
| * Note that it's for fast access without debug checking and only exists |
| * when __CUST_NEW__ is defined. |
| * |
| * CALLS |
| * Initialize one GPIO pin as INPUT or OUTPUT |
| * |
| * PARAMETERS |
| * direction: INPUT or OUTPUT |
| * port: pin number |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| */ |
| void GPIO_InitIO_FAST(char direction, kal_int16 port) |
| { |
| #ifdef __GPIO_FAST_DEBUB__ |
| if (gpio_debug_enable == KAL_TRUE) |
| { |
| if (direction == 0) |
| { |
| #ifdef __GPIO_CHECK_WARNING__ |
| if (!kal_if_lisr()) { |
| if (!((gpio_dir_in_allowed[(kal_uint8)port>>5]) & (1 << (port & 0x1f)))) |
| { |
| kal_int32 ret; |
| system_print("GPIO WARNING!! GPIO_InitIO_FAST: Direction Input is not allowed!"); |
| ret = sprintf(buff, "pin=%d", port); |
| system_print(buff); |
| } |
| } |
| #elif defined(__GPIO_CHECK_ASSERT__) |
| ASSERT((gpio_dir_in_allowed[(kal_uint8)port>>5]) & (1 << (port & 0x1f))); |
| #endif /* __GPIO_CHECK_WARNING__ */ |
| } |
| else |
| { |
| #ifdef __GPIO_CHECK_WARNING__ |
| if (!kal_if_lisr()) { |
| if (!((gpio_dir_out_allowed[(kal_uint8)port>>5]) & (1 << (port & 0x1f)))) |
| { |
| kal_int32 ret; |
| system_print("GPIO WARNING!! GPIO_InitIO_FAST: Direction Output is not allowed!"); |
| ret = sprintf(buff, "pin=%d", port); |
| system_print(buff); |
| } |
| } |
| #elif defined(__GPIO_CHECK_ASSERT__) |
| ASSERT((gpio_dir_out_allowed[(kal_uint8)port>>5]) & (1 << (port & 0x1f))); |
| #endif /* __GPIO_CHECK_WARNING__ */ |
| } |
| gpio_check_for_write[(kal_uint8)port>>5] |= (1 << (port & 0x1f)); |
| gpio_check_for_read[(kal_uint8)port>>5] |= (1 << (port & 0x1f)); |
| } |
| #endif /* __GPIO_FAST_DEBUB__ */ |
| |
| #ifdef __CUST_NEW__ |
| port &= (~GPIO_MAGIC_NUM); |
| #endif /* __CUST_NEW__ */ |
| if(GPIO_OUTPUT == direction) |
| { |
| GPIO_SET_DIRECT_OUTPUT((gpio_pin_e)port); |
| } |
| else |
| { |
| _GPIO_Set_Direction((gpio_pin_e)port,GPIO_INPUT); |
| } |
| } |
| |
| /* |
| * FUNCTION |
| * GPIO_WriteIO_FAST |
| * |
| * DESCRIPTION |
| * This function is to write data to one GPIO port |
| * Note that it's for fast access without debug checking and only exists |
| * when __CUST_NEW__ is defined. |
| * |
| * CALLS |
| * Write data to one GPIO port |
| * |
| * PARAMETERS |
| * data: KAL_TRUE(1) or KAL_FALSE(0) |
| * port: gpio pin number |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| */ |
| void GPIO_WriteIO_FAST(char data, kal_int16 port) |
| { |
| #ifdef __GPIO_FAST_DEBUB__ |
| if ((gpio_debug_enable == KAL_TRUE) && |
| (gpio_check_for_write[(kal_uint8)port>>5] & (1 << (port & 0x1f)))) |
| { |
| |
| #ifdef __GPIO_CHECK_WARNING__ |
| if (!kal_if_lisr()) { |
| kal_uint16 mode; |
| mode = GPIO_ReturnMode(port); |
| if (mode != 0) |
| { |
| kal_int32 ret; |
| system_print("GPIO WARNING!! GPIO_WriteIO_FAST: mode is not correct."); |
| ret = sprintf(buff, "pin=%d, mode=%d", port, mode); |
| system_print(buff); |
| } |
| #elif defined(__GPIO_CHECK_ASSERT__) |
| ASSERT(GPIO_ReturnMode(port) == 0); |
| #endif /* __GPIO_CHECK_WARNING__ */ |
| } |
| #ifdef __GPIO_CHECK_WARNING__ |
| if (!kal_if_lisr()) { |
| char dir; |
| dir = GPIO_ReturnDir(port); |
| if (dir != 1) |
| { |
| kal_int32 ret; |
| system_print("GPIO WARNING!! GPIO_WriteIO_FAST: direction is not correct."); |
| ret = sprintf(buff, "pin=%d, direction=%d", port, dir); |
| system_print(buff); |
| } |
| } |
| #elif defined(__GPIO_CHECK_ASSERT__) |
| ASSERT(GPIO_ReturnDir(port) == 1); |
| #endif /* __GPIO_CHECK_WARNING__ */ |
| gpio_check_for_write[(kal_uint8)port>>5] &= (~(1 << (port & 0x1f))); |
| } |
| #endif /* __GPIO_FAST_DEBUB__ */ |
| |
| #ifdef __CUST_NEW__ |
| port &= (~GPIO_MAGIC_NUM); |
| #endif |
| GPIO_WRITE_OUTPUT_VALUE((gpio_pin_e)port,data); |
| |
| } |
| |
| /* |
| * FUNCTION |
| * GPIO_ReadIO_FAST |
| * |
| * DESCRIPTION |
| * This function is to read data from one GPIO pin. |
| * Note that it's for fast access without debug checking and only exists |
| * when __CUST_NEW__ is defined. |
| * |
| * CALLS |
| * Read data from one GPIO pin |
| * |
| * PARAMETERS |
| * port: pin number |
| * |
| * RETURNS |
| * 1 or 0 |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| */ |
| char GPIO_ReadIO_FAST(kal_int16 port) |
| { |
| kal_uint32 input_val; |
| |
| #ifdef __GPIO_FAST_DEBUB__ |
| if ((gpio_debug_enable == KAL_TRUE) && |
| (gpio_check_for_read[(kal_uint8)port>>5] & (1 << (port & 0x1f)))) |
| { |
| #ifdef __GPIO_CHECK_WARNING__ |
| if (!kal_if_lisr()) { |
| kal_uint16 mode; |
| char dir; |
| mode = GPIO_ReturnMode(port); |
| dir = GPIO_ReturnDir(port); |
| if ((mode != 0) || (dir != 0)) |
| { |
| kal_int32 ret; |
| system_print("GPIO WARNING!! GPIO_ReadIO_FAST: mode or direction is not correct."); |
| ret = sprintf(buff, "pin=%d, mode=%d, direction=%d", port, mode, dir); |
| system_print(buff); |
| } |
| } |
| #elif defined(__GPIO_CHECK_ASSERT__) |
| ASSERT(GPIO_ReturnMode(port) == 0); |
| ASSERT(GPIO_ReturnDir(port) == 0); |
| #endif /* __GPIO_CHECK_WARNING__ */ |
| gpio_check_for_read[(kal_uint8)port>>5] &= (~(1 << (port & 0x1f))); |
| } |
| #endif /* __GPIO_FAST_DEBUB__ */ |
| |
| #ifdef __CUST_NEW__ |
| port &= (~GPIO_MAGIC_NUM); |
| #endif /* __CUST_NEW__ */ |
| |
| if(GPIO_READ_INPUT_VALUE((gpio_pin_e)port, &input_val) != GPIO_OK) |
| { |
| GPIO_ERR("\tGPIO_ReadIO: read the value of port[%d] failed!! ",port); |
| } |
| return (char)input_val; |
| } |
| |
| |
| #endif |
| |
| //#pragma arm section code = "INTERNCODE" |
| /* |
| * FUNCTION |
| * GPIO_WriteIO_FAST2 |
| * |
| * DESCRIPTION |
| * This function is to write data to one GPIO port |
| * Note that it's for faster access without debug checking. |
| * |
| * CALLS |
| * Write data to one GPIO port |
| * |
| * PARAMETERS |
| * data: KAL_TRUE(1) or KAL_FALSE(0) |
| * no: no = port/16; port: GPIO port number |
| * remainder_shift: remainder_shift = 1<<(port%16); |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| */ |
| void DEVDRV_LS_INTERNCODE GPIO_WriteIO_FAST2(char data, kal_uint16 no, kal_uint16 remainder_shift) |
| { |
| kal_uint32 gpio_pin,shift_bit; |
| |
| #if defined(__CUST_NEW__)&&defined(__GPIO_FAST_DEBUB__) |
| if ((gpio_debug_enable == KAL_TRUE) && |
| (gpio_check_for_write[(kal_uint8)port>>5] & (1 << (port & 0x1f)))) |
| { |
| kal_int16 port; |
| kal_uint16 index; |
| |
| for (index = 0; index < 16; index++) |
| { |
| if (remainder_shift & (1 << index)) |
| break; |
| } |
| port = (kal_int16)((no<<4)+(index&0x000f)); |
| |
| #ifdef __GPIO_CHECK_WARNING__ |
| if (!kal_if_lisr()) { |
| kal_uint16 mode; |
| mode = GPIO_ReturnMode(port); |
| if (mode != 0) |
| { |
| kal_int32 ret; |
| system_print("GPIO WARNING!! GPIO_WriteIO_FAST: mode is not correct."); |
| ret = sprintf(buff, "pin=%d, mode=%d", port, mode); |
| system_print(buff); |
| } |
| |
| #elif defined(__GPIO_CHECK_ASSERT__) |
| ASSERT(GPIO_ReturnMode(port) == 0); |
| #endif /* __GPIO_CHECK_WARNING__ */ |
| } |
| #ifdef __GPIO_CHECK_WARNING__ |
| if (!kal_if_lisr()) { |
| char dir; |
| dir = GPIO_ReturnDir(port); |
| if (dir != 1) |
| { |
| kal_int32 ret; |
| system_print("GPIO WARNING!! GPIO_WriteIO_FAST: direction is not correct."); |
| ret = sprintf(buff, "pin=%d, direction=%d", port, dir); |
| system_print(buff); |
| } |
| } |
| #elif defined(__GPIO_CHECK_ASSERT__) |
| ASSERT(GPIO_ReturnDir(port) == 1); |
| #endif /* __GPIO_CHECK_WARNING__ */ |
| gpio_check_for_write[(kal_uint8)port>>5] &= (~(1 << (port & 0x1f))); |
| } |
| #endif /* __GPIO_FAST_DEBUB__ */ |
| |
| for (shift_bit = 0; shift_bit < 16; shift_bit++) |
| { |
| if (remainder_shift & (1 << shift_bit)) |
| break; |
| } |
| gpio_pin = (kal_int16)((no<<4)+(shift_bit&0x000f)); |
| |
| GPIO_WRITE_OUTPUT_VALUE((gpio_pin_e)gpio_pin,data); |
| |
| } |
| |
| //#pragma arm section code |
| |
| |
| /*conf_data = 0~3*/ |
| void GPO_ModeSetup(kal_uint16 pin, kal_uint16 conf_dada) |
| { |
| //not support in MT6290 |
| } |
| |
| |
| /* |
| * FUNCTION |
| * GPI_O_WriteIO |
| * |
| * DESCRIPTION |
| * This function is to write data to one GPO pin |
| * |
| * CALLS |
| * Write data to one GPO pin |
| * |
| * PARAMETERS |
| * data: KAL_TRUE(1) or KAL_FALSE(0) |
| * port: gpo pin number |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| */ |
| |
| void GPO_WriteIO(char data,kal_int16 port) |
| { |
| //not support in MT6290 |
| } |
| |
| /* |
| * FUNCTION |
| * GPO_ReturnDout |
| * |
| * DESCRIPTION |
| * This function is to report GPO output value |
| * |
| * CALLS |
| * Report GPO output value accoding to input pin |
| * |
| * PARAMETERS |
| * GPO pin |
| * |
| * RETURNS |
| * GPO output value |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| */ |
| char GPO_ReturnDout(kal_int16 port) |
| { |
| return 0; |
| } |
| |
| |
| /* |
| * FUNCTION |
| * GPO_ReturnMode |
| * |
| * DESCRIPTION |
| * This function is to report GPO mode value |
| * |
| * CALLS |
| * Report GPO mode value accoding to input pin |
| * |
| * PARAMETERS |
| * GPO pin |
| * |
| * RETURNS |
| * GPO mode value |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| */ |
| char GPO_ReturnMode(kal_int16 port) |
| { |
| return 0; |
| } |
| |
| |
| /** |
| * @brief set gpio ownership register |
| * @param pin_num : the gpio pin to set ownerhsip |
| * @param ownership : the ownership register bit value to set ,it should be 0~1 |
| * 0: set ownership to MD |
| * 1: set ownership to AP |
| * @return GPIO_OK : set successful, GPIO_FAIL : set failed |
| */ |
| kal_int32 gpio_set_ownership(kal_uint32 pin_num,kal_uint32 ownership) |
| { |
| return GPIO_FAIL; |
| } |
| #if defined(MT6885) |
| #define DRIVING_SETTING_GPIO_NUM 8 |
| #define DRIVING_GEAR_NUM 2 |
| const gpio_driving_gear_t gpio_driving_gear[DRIVING_GEAR_NUM]= |
| { |
| { |
| 0x07, |
| 0x08, |
| { |
| {0x00,2}, |
| {0x01,4}, |
| {0x02,6}, |
| {0x03,8}, |
| {0x04,10}, |
| {0x05,12}, |
| {0x06,14}, |
| {0x07,16} |
| } |
| }, |
| }; |
| |
| const drv_gpio_driving_priv_t drv_gpio_driving_priv[DRIVING_SETTING_GPIO_NUM]= |
| { |
| {1,57,0, 6, 0xC1E20000}, |
| {1,58,0, 9, 0xC1E20000}, |
| {1,59,0,12, 0xC1E20000}, |
| {1,60,0,15, 0xC1E20000}, |
| {1,85,0,12, 0xC1E70000}, |
| {1,86,0,15, 0xC1E70000}, |
| {1,87,0, 6, 0xC1E70000}, |
| {1,88,0, 9, 0xC1E70000} |
| }; |
| #endif |
| #if defined(MT6873) |
| #define DRIVING_SETTING_GPIO_NUM 8 |
| #define DRIVING_GEAR_NUM 1 |
| const gpio_driving_gear_t gpio_driving_gear[DRIVING_GEAR_NUM]= |
| { |
| { |
| 0x07, |
| 0x08, |
| { |
| {0x00,2}, |
| {0x01,4}, |
| {0x02,6}, |
| {0x03,8}, |
| {0x04,10}, |
| {0x05,12}, |
| {0x06,14}, |
| {0x07,16} |
| } |
| }, |
| }; |
| const drv_gpio_driving_priv_t drv_gpio_driving_priv[DRIVING_SETTING_GPIO_NUM]= |
| { |
| {1,57,0,24, 0xC1D30010}, |
| {1,58,0,24, 0xC1D30010}, |
| {1,59,0,27, 0xC1D30010}, |
| {1,60,0,27, 0xC1D30010}, |
| {1,85,0,21, 0xC1D30010}, |
| {1,86,0,21, 0xC1D30010}, |
| {1,87,0,18, 0xC1D30010}, |
| {1,88,0,18, 0xC1D30010} |
| }; |
| #endif |
| #if defined(MT6853) |
| #define DRIVING_SETTING_GPIO_NUM 8 |
| #define DRIVING_GEAR_NUM 1 |
| const gpio_driving_gear_t gpio_driving_gear[DRIVING_GEAR_NUM]= |
| { |
| { |
| 0x07, |
| 0x08, |
| { |
| {0x00,2}, |
| {0x01,4}, |
| {0x02,6}, |
| {0x03,8}, |
| {0x04,10}, |
| {0x05,12}, |
| {0x06,14}, |
| {0x07,16} |
| } |
| }, |
| }; |
| const drv_gpio_driving_priv_t drv_gpio_driving_priv[DRIVING_SETTING_GPIO_NUM]= |
| { |
| {1,162,0,24, 0xC1D30000}, |
| {1,163,0,24, 0xC1D30000}, |
| {1,164,0,27, 0xC1D30000}, |
| {1,165,0,27, 0xC1D30000}, |
| {1,188,0,21, 0xC1D30000}, |
| {1,189,0,21, 0xC1D30000}, |
| {1,190,0,18, 0xC1D30000}, |
| {1,191,0,18, 0xC1D30000} |
| }; |
| #endif |
| #if defined(MT6833) |
| #define DRIVING_SETTING_GPIO_NUM 8 |
| #define DRIVING_GEAR_NUM 1 |
| const gpio_driving_gear_t gpio_driving_gear[DRIVING_GEAR_NUM]= |
| { |
| { |
| 0x07, |
| 0x08, |
| { |
| {0x00,2}, |
| {0x01,4}, |
| {0x02,6}, |
| {0x03,8}, |
| {0x04,10}, |
| {0x05,12}, |
| {0x06,14}, |
| {0x07,16} |
| } |
| }, |
| }; |
| const drv_gpio_driving_priv_t drv_gpio_driving_priv[DRIVING_SETTING_GPIO_NUM]= |
| { |
| {1,162,0,3, 0xC1D10030}, |
| {1,163,0,3, 0xC1D10030}, |
| {1,164,0,6, 0xC1D10030}, |
| {1,165,0,6, 0xC1D10030}, |
| {1,188,0,0, 0xC1D10030}, |
| {1,189,0,0, 0xC1D10030}, |
| {1,190,0,27, 0xC1D10020}, |
| {1,191,0,27, 0xC1D10020} |
| }; |
| #endif |
| #if defined(MT6877) |
| #define DRIVING_SETTING_GPIO_NUM 8 |
| #define DRIVING_GEAR_NUM 1 |
| const gpio_driving_gear_t gpio_driving_gear[DRIVING_GEAR_NUM]= |
| { |
| { |
| 0x07, |
| 0x08, |
| { |
| {0x00,2}, |
| {0x01,4}, |
| {0x02,6}, |
| {0x03,8}, |
| {0x04,10}, |
| {0x05,12}, |
| {0x06,14}, |
| {0x07,16} |
| } |
| }, |
| }; |
| const drv_gpio_driving_priv_t drv_gpio_driving_priv[DRIVING_SETTING_GPIO_NUM]= |
| { |
| {1,66,0, 3, 0xC1D30010}, |
| {1,67,0, 3, 0xC1D30010}, |
| {1,68,0, 0, 0xC1D30010}, |
| {1,69,0, 0, 0xC1D30010}, |
| {1,82,0,27, 0xC1D30000}, |
| {1,83,0,27, 0xC1D30000}, |
| {1,84,0,24, 0xC1D30000}, |
| {1,85,0,24, 0xC1D30000} |
| }; |
| #endif |
| #if defined(CHIP10992) |
| #define DRIVING_SETTING_GPIO_NUM 8 |
| #define DRIVING_GEAR_NUM 1 |
| const gpio_driving_gear_t gpio_driving_gear[DRIVING_GEAR_NUM]= |
| { |
| { |
| 0x07, |
| 0x08, |
| { |
| {0x00,2}, |
| {0x01,4}, |
| {0x02,6}, |
| {0x03,8}, |
| {0x04,10}, |
| {0x05,12}, |
| {0x06,14}, |
| {0x07,16} |
| } |
| }, |
| }; |
| const drv_gpio_driving_priv_t drv_gpio_driving_priv[DRIVING_SETTING_GPIO_NUM]= |
| { |
| {1,138,0,3, 0xC1D20000}, |
| {1,139,0,3, 0xC1D20000}, |
| {1,140,0,0, 0xC1D20000}, |
| {1,141,0,0, 0xC1D20000}, |
| {1,164,0,18, 0xC1C10010}, |
| {1,165,0,18, 0xC1C10010}, |
| {1,166,0,21, 0xC1C10010}, |
| {1,167,0,21, 0xC1C10010} |
| }; |
| #endif |
| /** |
| * @brief set the drive parameter of the gpio pin. |
| * @param gpio_pin : The pin which is to set drive. |
| * @param drive: the value of drive parameter to set, it should be 0~3 |
| * @return GPIO_OK : set successful, GPIO_FAIL : set failed |
| */ |
| kal_int32 gpio_set_drive(gpio_pin_e gpio_pin,kal_uint32 drive) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MERCURY) |
| return GPIO_FAIL; |
| #elif defined(MT6885)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| kal_uint8 temp0,temp1; |
| kal_uint8 result = 0; |
| const drv_gpio_driving_priv_t *pGpio_driving_priv; |
| for(temp0=0;temp0<DRIVING_SETTING_GPIO_NUM;temp0++) |
| { |
| if(drv_gpio_driving_priv[temp0].valid) |
| { |
| pGpio_driving_priv = (drv_gpio_driving_priv + temp0); |
| if(drv_gpio_driving_priv[temp0].gpio_num==gpio_pin) |
| { |
| for(temp1=0;temp1<gpio_driving_gear[pGpio_driving_priv->driving_gear].gear_cnt;temp1++) |
| { |
| if((gpio_driving_gear[pGpio_driving_priv->driving_gear].gear_mapping[temp1][1])==drive) |
| { |
| DRV_WriteReg32((pGpio_driving_priv->addr+8), |
| ((gpio_driving_gear[pGpio_driving_priv->driving_gear].mask) << (pGpio_driving_priv->offset))); |
| DRV_WriteReg32((pGpio_driving_priv->addr+4), |
| ((gpio_driving_gear[pGpio_driving_priv->driving_gear].gear_mapping[temp1][0]) << (pGpio_driving_priv->offset))); |
| result = 1; |
| break; |
| } |
| } |
| } |
| } |
| } |
| if(result==1) |
| return GPIO_OK; |
| else |
| return GPIO_FAIL; |
| #else |
| return GPIO_FAIL; |
| #endif |
| } |
| |
| |
| //======================================================================== |
| /** |
| * @brief get drive register value of pin |
| * @param gpio_pin : The GPIO pin to be read. |
| * @return return the drive register value of pin, it should be 0x0~0x3. |
| * if gpio_pin is out of range, the return value will be GPIO_FAIL |
| */ |
| kal_int32 gpio_get_drive_value(gpio_pin_e gpio_pin) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| return GPIO_FAIL; |
| #endif |
| } |
| |
| |
| |
| /** |
| * @brief set gpio ownership register |
| * @param pin_num : the gpio pin to set ownerhsip |
| * @param ownership : the ownership register bit value to set ,it should be 0~1 |
| * 0: set ownership to MD |
| * 1: set ownership to AP |
| * @return GPIO_OK : set successful, GPIO_FAIL : set failed |
| */ |
| kal_int32 gpio_get_ownership(kal_uint32 pin_num) |
| { |
| return GPIO_FAIL; |
| } |
| |
| void GPIO_MetaModeInit(void) |
| { |
| } |
| |
| kal_int32 GPIO_GetMetaMode(void) |
| { |
| #if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992) |
| return GPIO_FAIL; |
| #endif |
| } |
| |