Ejemplo n.º 1
0
int poweroff_main(int argc, char *argv[])
{
  /* TODO:
   *  - replace this by sending general system signal to shutdown, where i.e. nsh
   *    must issue down script (it may check whether nsh is running before spawning
   *    a new process with nsh poweroff)
   *  - wait for some time (~0.5 second for VSN), that SDcard is flashed and synced
   *  - call poweroff
   * 
   * TODO on boot:
   *  - if external key is pressed, do not start the nsh! but wait until it is released
   *    (to get rid of bad mounts of the sdcard etc.) this could be handled in the 
   *    button driver immediately on system boot
   */

  board_power_off();
  return 0;
}
Ejemplo n.º 2
0
STATIC ssize_t store_dev_test(struct device *dev, struct kobj_attribute *attr, const char *buf, size_t count)
{
    int32 cmd;
    int32 ret;
    struct ps_core_s *ps_core_d = NULL;
    struct st_exception_info *pst_exception_data = NULL;

    PS_PRINT_INFO("%s\n", __func__);

    if (NULL == buf)
    {
        PS_PRINT_ERR("buf is NULL\n");
        return -FAILURE;
    }

    get_exception_info_reference(&pst_exception_data);
    if (NULL == pst_exception_data)
    {
        PS_PRINT_ERR("get exception info reference is error\n");
        return 0;
    }

    ps_get_core_reference(&ps_core_d);
    if (unlikely(NULL == ps_core_d))
    {
        PS_PRINT_ERR("ps_core_d is NULL\n");
        return -EINVAL;
    }

    cmd = simple_strtol(buf, NULL, 10);
    switch (cmd)
    {
        case 1:
            ret = prepare_to_visit_node(ps_core_d);
            if (ret < 0)
            {
                PS_PRINT_ERR("prepare work FAIL\n");
                return ret;
            }

            PS_PRINT_INFO("bfgx test cmd %d, cause device panic\n", cmd);
            ps_tx_sys_cmd(ps_core_d, SYS_MSG, SYS_CFG_DEV_PANIC);

            post_to_visit_node(ps_core_d);
            break;
        case 2:
            PS_PRINT_INFO("cmd %d,enable platform dfr\n", cmd);
            pst_exception_data->exception_reset_enable = PLAT_EXCEPTION_ENABLE;
            break;
        case 3:
            PS_PRINT_INFO("cmd %d,enable wifi open bcpu\n", cmd);
            wifi_open_bcpu_set(1);
            break;
        case 4:
            PS_PRINT_INFO("cmd %d,test pull up power gpio\n", cmd);
            switch(g_device_subchip_type)
            {
                case BOARD_VERSION_HI1102:
                    board_power_on(WLAN_POWER);
                    break;
                case BOARD_VERSION_HI1103:
                    board_power_on(WLAN_POWER);
                    board_power_on(BFGX_POWER);
                    break;
                default:
                    PS_PRINT_ERR("g_device_subchip_type =%d error\n", g_device_subchip_type);
                    break;
            }
            break;
        case 5:
            PS_PRINT_INFO("cmd %d,test pull down power gpio\n", cmd);
            switch(g_device_subchip_type)
            {
                case BOARD_VERSION_HI1102:
                    board_power_off(WLAN_POWER);
                    break;
                case BOARD_VERSION_HI1103:
                    board_power_off(WLAN_POWER);
                    board_power_off(BFGX_POWER);
                    break;
                default:
                    PS_PRINT_ERR("g_device_subchip_type =%d error\n", g_device_subchip_type);
                    break;
            }
            break;
        case 6:
            PS_PRINT_INFO("cmd %d,start uart loop test\n", cmd);
            uart_loop_test();
            break;

        default:
            PS_PRINT_ERR("unknown cmd %d\n", cmd);
            break;
    }

    return count;
}
Ejemplo n.º 3
0
int boardctl(unsigned int cmd, uintptr_t arg)
{
  int ret;

  switch (cmd)
    {
      /* CMD:           BOARDIOC_INIT
       * DESCRIPTION:   Perform one-time application initialization.
       * ARG:           None
       * CONFIGURATION: CONFIG_LIB_BOARDCTL
       * DEPENDENCIES:  Board logic must provide board_app_initialization
       */

      case BOARDIOC_INIT:
        {
          ret = board_app_initialize();
        }
        break;

#ifdef CONFIG_BOARDCTL_POWEROFF
      /* CMD:           BOARDIOC_POWEROFF
       * DESCRIPTION:   Power off the board
       * ARG:           Integer value providing power off status information
       * CONFIGURATION: CONFIG_BOARDCTL_POWEROFF
       * DEPENDENCIES:  Board logic must provide board_power_off
       */

      case BOARDIOC_POWEROFF:
        {
          ret = board_power_off((int)arg);
        }
        break;
#endif

#ifdef CONFIG_BOARDCTL_RESET
      /* CMD:           BOARDIOC_RESET
       * DESCRIPTION:   Reset the board
       * ARG:           Integer value providing power off status information
       * CONFIGURATION: CONFIG_BOARDCTL_RESET
       * DEPENDENCIES:  Board logic must provide board_reset
       */

      case BOARDIOC_RESET:
        {
          ret = board_reset((int)arg);
        }
        break;
#endif

#ifdef CONFIG_BOARDCTL_TSCTEST
      /* CMD:           BOARDIOC_TSCTEST_SETUP
       * DESCRIPTION:   Touchscreen controller test configuration
       * ARG:           Touch controller device minor number
       * CONFIGURATION: CONFIG_LIB_BOARDCTL && CONFIG_BOARDCTL_TSCTEST
       * DEPENDENCIES:  Board logic must provide board_tsc_setup()
       */

      case BOARDIOC_TSCTEST_SETUP:
        {
          ret = board_tsc_setup((int)arg);
        }
        break;

      /* CMD:           BOARDIOC_TSCTEST_TEARDOWN
       * DESCRIPTION:   Touchscreen controller test configuration
       * ARG:           None
       * CONFIGURATION: CONFIG_LIB_BOARDCTL && CONFIG_BOARDCTL_TSCTEST
       * DEPENDENCIES:  Board logic must provide board_tsc_teardown()
       */

      case BOARDIOC_TSCTEST_TEARDOWN:
        {
          board_tsc_teardown();
          ret = OK;
        }
        break;
#endif

#ifdef CONFIG_BOARDCTL_ADCTEST
      /* CMD:           BOARDIOC_ADCTEST_SETUP
       * DESCRIPTION:   ADC controller test configuration
       * ARG:           None
       * CONFIGURATION: CONFIG_LIB_BOARDCTL && CONFIG_BOARDCTL_ADCTEST
       * DEPENDENCIES:  Board logic must provide board_adc_setup()
       */

      case BOARDIOC_ADCTEST_SETUP:
        {
          ret = board_adc_setup();
        }
        break;
#endif

#ifdef CONFIG_BOARDCTL_PWMTEST
      /* CMD:           BOARDIOC_PWMTEST_SETUP
       * DESCRIPTION:   PWM controller test configuration
       * ARG:           None
       * CONFIGURATION: CONFIG_LIB_BOARDCTL && CONFIG_BOARDCTL_PWMTEST
       * DEPENDENCIES:  Board logic must provide board_pwm_setup()
       */

      case BOARDIOC_PWMTEST_SETUP:
        {
          ret = board_pwm_setup();
        }
        break;
#endif

#ifdef CONFIG_BOARDCTL_GRAPHICS
      /* CMD:           BOARDIOC_GRAPHICS_SETUP
       * DESCRIPTION:   Configure graphics that require special initialization
       *                procedures
       * ARG:           A pointer to an instance of struct boardioc_graphics_s
       * CONFIGURATION: CONFIG_LIB_BOARDCTL && CONFIG_BOARDCTL_GRAPHICS
       * DEPENDENCIES:  Board logic must provide board_adc_setup()
       */

      case BOARDIOC_GRAPHICS_SETUP:
        {
          FAR struct boardioc_graphics_s *setup = 
            ( FAR struct boardioc_graphics_s *)arg;

          setup->dev = board_graphics_setup(setup->devno);
          ret = setup->dev ? OK : -ENODEV;
        }
        break;
#endif

       default:
         {
#ifdef CONFIG_BOARDCTL_IOCTL
           /* Boards may also select CONFIG_BOARDCTL_IOCTL=y to enable board-
            * specific commands.  In this case, all commands not recognized
            * by boardctl() will be forwarded to the board-provided board_ioctl()
            * function.
            */

           ret = board_ioctl(cmd, arg);
#else
           ret = -ENOTTY;
#endif
         }
         break;
    }

  /* Set the errno value on any errors */

  if (ret < 0)
    {
      set_errno(-ret);
      return ERROR;
    }

  return OK;
}