packages/ti/board/diag/button/src/button_test.c

   1 /*
   2  * Copyright (C) 2016-2020 Texas Instruments Incorporated - http://www.ti.com/
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *
  11  * Redistributions in binary form must reproduce the above copyright
  12  * notice, this list of conditions and the following disclaimer in the
  13  * documentation and/or other materials provided with the
  14  * distribution.
  15  *
  16  * Neither the name of Texas Instruments Incorporated nor the names of
  17  * its contributors may be used to endorse or promote products derived
  18  * from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  */
  33
  34 /**
  35  * \file   button_test.c
  36  *
  37  * \brief  Push button diagnostic test file
  38  *
  39  *  Targeted Functionality: Verification of basic functionality of
  40  *  available push buttons.
  41  *
  42  *  Operation: This application demonstrates the working of GPIO based button
  43  *             keypad. It waits for a key press event from the button keypad.
  44  *             On a key press the diagnostic test sequentially moves to the
  45  *             other buttons in the keypad.
  46  *
  47  *  Supported SoCs: AM335x, AM437x, AM65xx, TPR12,AM64x.
  48  *
  49  *  Supported Platforms: skAM335x, skAM437x, evmAM437x am65xx_evm, am65xx_idk,
  50  *                       tpr12_evm,am64x_evm.
  51  *
  52  */
  53
  54 #include "button_test.h"
  55
  56 #if defined(SOC_TPR12)
  57 extern GPIO_v2_Config GPIO_v2_config;
  58 #endif
  59
  60 uint32_t buttonOffset[2]={0, 0};
  61 uint32_t powerOffset[2]={0, 0};
  62 uint32_t buttonStart[2]={0, 0};
  63
  64 /* Variable to hold the GPIO key info. */
  65 gpioInfo_t KeyScn[4];
  66
  67 /**
  68  *  \brief   Push Button diagnostic test main function
  69  *
  70  *  \return  int - Push Button diagnostic test status.
  71  *            S_PASS - if the board id matches
  72  *            E_FAIL - if the board id fails.
  73  *
  74  */
  75 int main(void)
  76 {
  77     int status = S_PASS;
  78 #if (defined(SOC_AM65XX) || defined(SOC_TPR12) || defined(SOC_AM64X))
  79     Board_IDInfo_v2 info;
  80 #else
  81     Board_IDInfo boardInfo;
  82 #endif
  83     keyPadInfo_t boardKeyPad;
  84     Board_initCfg boardCfg;
  85
  86 #ifdef SOC_K2G
  87     DIAG_IntrInit();
  88 #endif
  89
  90 #ifdef PDK_RAW_BOOT
  91     boardCfg = BOARD_INIT_MODULE_CLOCK |
  92                BOARD_INIT_PINMUX_CONFIG |
  93                BOARD_INIT_UART_STDIO;
  94 #else
  95     boardCfg = BOARD_INIT_UART_STDIO;
  96 #endif
  97     Board_init(boardCfg);
  98
  99     UART_printf("\n*********************************************\n");
 100     UART_printf  ("*                 Button Test               *\n");
 101     UART_printf  ("*********************************************\n");
 102
 103 #if (defined(SOC_AM65XX) || defined(SOC_TPR12) || defined(SOC_AM64X))
 104     Board_getIDInfo_v2(&info, BOARD_I2C_EEPROM_ADDR);
 105 #else
 106     Board_getIDInfo(&boardInfo);
 107 #endif
 108
 109     /* Update the KeyPad information. */
 110 #if (defined(SOC_AM65XX) || defined(SOC_TPR12) || defined(SOC_AM64X))
 111     status = BoardDiag_GetKeyPadInfo(info.boardInfo.boardName, &boardKeyPad);
 112 #else
 113     status = BoardDiag_GetKeyPadInfo(boardInfo.boardName, &boardKeyPad);
 114 #endif
 115     if(S_PASS == status)
 116     {
 117         status = BoardDiag_ButtonTest(&boardKeyPad);
 118
 119         if(S_PASS == status)
 120         {
 121             UART_printf("Test PASSED! \n");
 122         }
 123         else
 124         {
 125             UART_printf("Test Failed!\n");
 126         }
 127     }
 128
 129     return status;
 130 }
 131
 132 /**
 133  * \brief   This function is used enable the power key by making the power
 134  *          key GPIO line high.
 135  *
 136  * \param   *pBoardKeyPad     [IN]      Structure pointer consisting of the
 137  *                                      Keypad information of the board
 138  * \param   num               [IN]      Power key number.
 139  *
 140  * \retval  S_PASS  if the board id matches
 141  * \retval  E_FAIL  if the board id fails.
 142  *
 143  */
 144 void BoardDiag_BtnPwr(keyPadInfo_t *pBoardKeyPad, uint32_t num)
 145 {
 146     uint32_t i = 0U;
 147
 148     for(i = 0; i < pBoardKeyPad->pwrKeyNum; i++)
 149     {
 150         if(i == num)
 151         {
 152             GPIO_write(pBoardKeyPad->pwrKeyIdx + i, GPIO_PIN_VAL_HIGH);
 153         }
 154         else
 155         {
 156             GPIO_write(pBoardKeyPad->pwrKeyIdx + i, GPIO_PIN_VAL_LOW);
 157         }
 158     }
 159 }
 160
 161 /**
 162  * \brief   This function is used to perform the push button diagnostic test.
 163  *
 164  * \param   *pBoardKeyPad     [IN]      Structure pointer consisting of the
 165  *                                      Keypad information of the board.
 166  *
 167  * \retval  S_PASS  if the board id matches
 168  * \retval  E_FAIL  if the board id fails.
 169  *
 170  */
 171 int32_t BoardDiag_ButtonTest(keyPadInfo_t *pBoardKeyPad)
 172 {
 173     uint32_t retVal = S_PASS;
 174     uint32_t i, j, k;
 175
 176     /* Initialize the GPIO driver. */
 177     UART_printf("\nRunning button test...\n");
 178 #if defined(SOC_AM65XX)
 179     GPIO_v0_HwAttrs gpioCfg;
 180     GPIO_socGetInitCfg(0, &gpioCfg);
 181     gpioCfg.baseAddr = CSL_WKUP_GPIO0_BASE;
 182     GPIO_socSetInitCfg(0, &gpioCfg);
 183     GPIO_init();
 184 #elif defined(SOC_AM64X)
 185     GPIO_init();
 186
 187     GPIO_v0_HwAttrs gpioCfg;
 188     GPIO_socGetInitCfg(1, &gpioCfg);
 189     gpioCfg.baseAddr = CSL_MCU_GPIO0_BASE;
 190     GPIO_socSetInitCfg(1, &gpioCfg);
 191     GPIO_init();
 192 #else
 193 #if defined(SOC_TPR12)
 194     GPIO_v2_updateConfig(&GPIO_v2_config);
 195 #endif
 196     GPIO_init();
 197 #endif
 198
 199     for(k=0; k < pBoardKeyPad->buttonSet; k++)
 200     {
 201         for(i=0; i< pBoardKeyPad->pwrKeyNum; i++)
 202         {
 203             for(j=0; j < pBoardKeyPad->scnKeyNum; j++)
 204             {
 205                 retVal = BoardDiag_KeyPressCheck(pBoardKeyPad,
 206                                                  buttonStart[k] + (i*powerOffset[k]) + (j*buttonOffset[k]),
 207                                                  j, i);
 208             }
 209         }
 210     }
 211
 212     return retVal;
 213 }
 214
 215 /**
 216  * \brief   This is used for keep on checking for a specified button to
 217  *          be pressed.
 218  *
 219  * \param   *pBoardKeyPad     [IN]      Structure pointer consisting of the
 220  *                                      Keypad information of the board.
 221  * \param   button            [IN]      Push button switch number.
 222  * \param   scnKey            [IN]      Push button switch index.
 223  * \param   pwrKey            [IN]      Power key number.
 224  *
 225  * \retval  S_PASS  if the board id matches
 226  * \retval  E_FAIL  if the board id fails.
 227  *
 228  */
 229 int32_t BoardDiag_KeyPressCheck(keyPadInfo_t *pBoardKeyPad,
 230                                 uint32_t button,
 231                                 uint32_t scnKey,
 232                                 uint32_t pwrKey)
 233 {
 234     int32_t ret_val=0;
 235     uint32_t level = 0U;
 236 #if defined (DIAG_COMPLIANCE_TEST)
 237     UART_printf(  "Button SW %2d            ", button);
 238
 239     level = GPIO_read(scnKey);
 240
 241     UART_printf("Button SW %2d Value - %d\n", button, level);
 242     ret_val = S_PASS;
 243
 244     return ret_val;
 245 #else
 246     UART_printf(  "Button SW %2d            ", button);
 247     UART_printf("WAIT      Waiting for button press");
 248
 249 #if (defined(SOC_AM65XX) || defined(SOC_TPR12) || defined(SOC_AM64X))
 250     do
 251     {
 252 #if defined(SOC_TPR12)
 253         level = GPIO_read(GPIO_v2_config.pinConfigs[scnKey].pinIndex);
 254 #else
 255         level = GPIO_read(scnKey);
 256 #endif
 257 #if defined(SOC_TPR12)
 258     }while(level == 0);
 259 #else
 260     }while(level == 1);
 261 #endif
 262     UART_printf("...   Button %2d Pressed \n", button);
 263
 264     UART_printf(  "Button SW %2d            ", button);
 265     UART_printf("WAIT      Waiting for button release...");
 266     do
 267     {
 268 #if defined(SOC_TPR12)
 269         level = GPIO_read(GPIO_v2_config.pinConfigs[scnKey].pinIndex);
 270 #else
 271         level = GPIO_read(scnKey);
 272 #endif
 273 #if defined(SOC_TPR12)
 274     }while(level == 1);
 275 #else
 276     }while(level == 0);
 277 #endif
 278     UART_printf(" Button %2d released\n", button);
 279 #else
 280     BoardDiag_BtnPwr(pBoardKeyPad, pwrKey);
 281     do
 282     {
 283         level = (GPIO_read(scnKey));
 284     }while(level != 1);
 285 #endif
 286
 287     UART_printf("Button SW %2d            ", button);
 288
 289 #if (!(defined(SOC_AM65XX) || defined(SOC_TPR12) || defined(SOC_AM64X)))
 290     if(level != 1)
 291     {
 292         UART_printf("FAIL                                            \n");
 293         ret_val = E_FAIL;
 294     }
 295     else
 296     {
 297         UART_printf("PASS                                            \n");
 298         ret_val = S_PASS;
 299     }
 300 #else
 301     UART_printf("PASS                                            \n");
 302     ret_val = S_PASS;
 303 #endif
 304     return ret_val;
 305 #endif
 306 }
 307
 308 /**
 309  * \brief   Get the Board keypad information as per the board Id.
 310  *
 311  * \param   *pBoardName       [IN]      Pointer to hold the board name
 312  * \param   *pBoardKeyPad     [OUT]     Structure pointer for holding the
 313  *                                      Keypad information of the board.
 314  *
 315  * \retval  S_PASS  if the board id matches
 316  * \retval  E_FAIL  if the board id fails.
 317  *
 318  */
 319 int32_t BoardDiag_GetKeyPadInfo(char *pBoardName, keyPadInfo_t *pBoardKeyPad)
 320 {
 321     int32_t status = S_PASS;
 322
 323     /* Check if the board is AM437x GPEVM by comparing the string
 324        read from EEPROM. */
 325     if (strncmp("AM43__GP", pBoardName, BOARD_NAME_LENGTH) == 0U)
 326     {
 327         pBoardKeyPad->buttonSet = 1;
 328         pBoardKeyPad->scnKeyNum = 3;
 329         pBoardKeyPad->pwrKeyNum = 2;
 330         pBoardKeyPad->pwrKeyIdx = 3;
 331         buttonStart[0]=4;
 332         buttonOffset[0]=1;
 333         powerOffset[0]=3;
 334         /* Update the GPIO data for keypad inputs. */
 335         KeyScn[0].instance=3;
 336         KeyScn[0].pin=21;
 337
 338         KeyScn[1].instance=4;
 339         KeyScn[1].pin=3;
 340
 341         KeyScn[2].instance=4;
 342         KeyScn[2].pin=2;
 343     }
 344     /* Check if the board is SKAM437x by comparing the string read
 345        from EEPROM. */
 346     else if (strncmp("AM43__SK", pBoardName, BOARD_NAME_LENGTH) == 0U)
 347     {
 348         pBoardKeyPad->buttonSet = 1;
 349         pBoardKeyPad->scnKeyNum = 2;
 350         pBoardKeyPad->pwrKeyNum = 2;
 351         pBoardKeyPad->pwrKeyIdx = 2;
 352         buttonStart[0]=6;
 353         buttonOffset[0]=1;
 354         powerOffset[0]=2;
 355
 356         /* Update the GPIO data for keypad inputs. */
 357         KeyScn[0].instance=5;
 358         KeyScn[0].pin=5;
 359
 360         KeyScn[1].instance=5;
 361         KeyScn[1].pin=6;
 362     }
 363     /* Check if the board is SKAM335x by comparing the string read
 364        from EEPROM. */
 365     else if (strncmp("A335X_SK", pBoardName, BOARD_NAME_LENGTH) == 0U)
 366     {
 367         pBoardKeyPad->buttonSet = 1;
 368         pBoardKeyPad->scnKeyNum = 4;
 369         pBoardKeyPad->pwrKeyNum = 1;
 370         pBoardKeyPad->pwrKeyIdx = 0;
 371         buttonStart[0]=1;
 372         buttonOffset[0]=1;
 373         powerOffset[0]=1;
 374
 375         /*
 376         ** Note: For skAM335x board the order of key press on the keypad should
 377                  be in the following order
 378         1: Key1: SW3 corresponding to SW3 switch on board.
 379         2: Key2: SW1 corresponding to SW1 switch on board.
 380         3: Key3: SW2 corresponding to SW2 switch on board.
 381         4: Key4: SW4 corresponding to SW4 switch on board.
 382         */
 383         KeyScn[0].instance=0;
 384         KeyScn[0].pin=30;
 385
 386         KeyScn[1].instance=2;
 387         KeyScn[1].pin=3;
 388
 389         KeyScn[2].instance=2;
 390         KeyScn[2].pin=2;
 391
 392         KeyScn[3].instance=2;
 393         KeyScn[3].pin=5;
 394     }
 395     /* Check if the board is EVM AM65XX by comparing the string read from
 396        EEPROM. */
 397     else if (strncmp("AM6-COMP", pBoardName, BOARD_NAME_LENGTH) == 0U)
 398     {
 399
 400         pBoardKeyPad->buttonSet = 1;
 401         pBoardKeyPad->scnKeyNum = 2;
 402         pBoardKeyPad->pwrKeyNum = 1;
 403         pBoardKeyPad->pwrKeyIdx = 0;
 404         buttonStart[0]=5;
 405         buttonOffset[0]=1;
 406         powerOffset[0]=1;
 407
 408         /* Update the GPIO data for keypad inputs. */
 409         KeyScn[0].instance=0;
 410         KeyScn[0].pin=24;
 411
 412         KeyScn[1].instance=0;
 413         KeyScn[1].pin=27;
 414     }
 415 #if defined(SOC_TPR12)
 416     /* TODO: Need to update after programming board ID EEPROM
 417      * Check if the board is EVM TPR12 by comparing the string read from
 418        EEPROM. */
 419     else if(status == S_PASS)
 420     {
 421
 422         pBoardKeyPad->buttonSet = 1;
 423         pBoardKeyPad->scnKeyNum = 1;
 424         pBoardKeyPad->pwrKeyNum = 1;
 425         pBoardKeyPad->pwrKeyIdx = 0;
 426         buttonStart[0]=2;
 427         buttonOffset[0]=1;
 428         powerOffset[0]=1;
 429
 430         /* Update the GPIO data for keypad inputs. */
 431         KeyScn[0].instance=0;
 432         KeyScn[0].pin=28;
 433
 434     }
 435 #endif
 436     /* Check if the board is EVM AM64X by comparing the string read from
 437        EEPROM. */
 438     else if (strncmp("AM64-COMP", pBoardName, BOARD_NAME_LENGTH) == 0U)
 439     {
 440
 441         pBoardKeyPad->buttonSet = 1;
 442         pBoardKeyPad->scnKeyNum = 2;
 443         pBoardKeyPad->pwrKeyNum = 1;
 444         pBoardKeyPad->pwrKeyIdx = 0;
 445         buttonStart[0]=5;
 446         buttonOffset[0]=1;
 447         powerOffset[0]=1;
 448
 449         /* Update the GPIO data for keypad inputs. */
 450         KeyScn[0].instance=1;
 451         KeyScn[0].pin=43;
 452
 453         KeyScn[1].instance=0;
 454         KeyScn[1].pin=6;
 455     }
 456     else
 457     {
 458         status = E_FAIL;
 459         UART_printf("The test is not supported on this board\n");
 460     }
 461
 462     return status;
 463 }