path: root/src/hal-api-device-board.c

/*
 * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <hal/hal-common.h>

#include "hal-device-board-interface.h"
#include "common.h"

static hal_backend_device_board_funcs *hal_device_board_funcs = NULL;

int hal_device_board_get_backend(void)
{
	int ret;

	if (hal_device_board_funcs)
		return 0;

	hal_device_board_funcs = calloc(1, sizeof(hal_backend_device_board_funcs));
	if (!hal_device_board_funcs)
		return -ENOMEM;

	ret = hal_common_get_backend(HAL_MODULE_DEVICE_BOARD, (void **)&hal_device_board_funcs);
	if (ret < 0) {
		 _E("Failed to get device-board backend");
		free(hal_device_board_funcs);
		hal_device_board_funcs = NULL;
		return -EINVAL;
	}

	return 0;
}

int hal_device_board_put_backend(void)
{
	if (!hal_device_board_funcs)
		return 0;

	hal_common_put_backend(HAL_MODULE_DEVICE_BOARD, (void *)hal_device_board_funcs);
	free(hal_device_board_funcs);
	hal_device_board_funcs = NULL;

	return 0;
}

int hal_device_board_get_device_serial_number(char *buffer, const int max_len)
{
	int ret ;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->get_device_serial_number)
		return -ENODEV;

	return hal_device_board_funcs->get_device_serial_number(buffer, max_len);
}

int hal_device_board_get_device_revision(int *revision)
{
	int ret ;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->get_device_revision)
		return -ENODEV;

	return hal_device_board_funcs->get_device_revision(revision);
}

int hal_device_board_set_boot_success(void)
{
	int ret;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->set_boot_success)
		return -ENODEV;

	return hal_device_board_funcs->set_boot_success();
}


int hal_device_board_clear_boot_mode(void)
{
	int ret;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->clear_boot_mode)
		return -ENODEV;

	return hal_device_board_funcs->clear_boot_mode();
}

int hal_device_board_get_boot_mode(char *buffer, const int max_len)
{
	int ret;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->get_boot_mode)
		return -ENODEV;

	return hal_device_board_funcs->get_boot_mode(buffer, max_len);
}

int hal_device_board_get_boot_reason(char *buffer, const int max_len)
{
	int ret;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->get_boot_reason)
		return -ENODEV;

	return hal_device_board_funcs->get_boot_reason(buffer, max_len);
}

int hal_device_board_get_current_partition(char *partition_ab)
{
	int ret;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->get_current_partition)
		return -ENODEV;

	return hal_device_board_funcs->get_current_partition(partition_ab);
}

int hal_device_board_switch_partition(char partition_ab)
{
	int ret;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->switch_partition)
		return -ENODEV;

	return hal_device_board_funcs->switch_partition(partition_ab);
}

int hal_device_board_set_partition_ab_cloned(void)
{
	int ret;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->set_partition_ab_cloned)
		return -ENODEV;

	return hal_device_board_funcs->set_partition_ab_cloned();
}

int hal_device_board_clear_partition_ab_cloned(void)
{
	int ret;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->clear_partition_ab_cloned)
		return -ENODEV;

	return hal_device_board_funcs->clear_partition_ab_cloned();
}

int hal_device_board_get_partition_ab_cloned(int *cloned)
{
	int ret;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->get_partition_ab_cloned)
		return -ENODEV;

	return hal_device_board_funcs->get_partition_ab_cloned(cloned);
}

int hal_device_board_set_partition_status(char partition_ab, const char *status)
{
	int ret;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->set_partition_status)
		return -ENODEV;

	return hal_device_board_funcs->set_partition_status(partition_ab, status);
}

int hal_device_board_get_partition_status(char partition_ab, char *buffer, const int max_len)
{
	int ret;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->get_partition_status)
		return -ENODEV;

	return hal_device_board_funcs->get_partition_status(partition_ab, buffer, max_len);
}

int hal_device_board_set_upgrade_progress_status(int status)
{
	int ret;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->set_upgrade_progress_status)
		return -ENODEV;

	return hal_device_board_funcs->set_upgrade_progress_status(status);
}

int hal_device_board_get_upgrade_progress_status(int *status)
{
	int ret;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->get_upgrade_progress_status)
		return -ENODEV;

	return hal_device_board_funcs->get_upgrade_progress_status(status);
}

#define UPGRADE_STATE_STANDBY "standby"
#define UPGRADE_STATE_READY "ready"
#define UPGRADE_STATE_READY_FAILED "ready_failed"
#define UPGRADE_STATE_RO_UPGRADING "ro_upgrading"
#define UPGRADE_STATE_RO_FAILED "ro_failed"
#define UPGRADE_STATE_RO_UPGRADED "ro_upgraded"
#define UPGRADE_STATE_RW_UPGRADING "rw_upgrading"
#define UPGRADE_STATE_RW_FAILED "rw_failed"
#define UPGRADE_STATE_RW_UPGRADED "rw_upgraded"
#define UPGRADE_STATE_COMPLETED "completed"

struct upgrade_state {
	char *state;
	size_t next_size;
	char *next[3];
};

static struct upgrade_state upgrade_states[] = {
	{
		.state = UPGRADE_STATE_STANDBY,
		.next_size = 1,
		.next = {
			UPGRADE_STATE_READY,
		},
	}, {
		.state = UPGRADE_STATE_READY,
		.next_size = 2,
		.next = {
			UPGRADE_STATE_READY_FAILED,
			UPGRADE_STATE_RO_UPGRADING,
		},
	}, {
		.state = UPGRADE_STATE_READY_FAILED,
		.next_size = 1,
		.next = {
			UPGRADE_STATE_READY,
		},
	}, {
		.state = UPGRADE_STATE_RO_UPGRADING,
		.next_size = 2,
		.next = {
			UPGRADE_STATE_RO_FAILED,
			UPGRADE_STATE_RO_UPGRADED,
		},
	}, {
		.state = UPGRADE_STATE_RO_FAILED,
		.next_size = 1,
		.next = {
			UPGRADE_STATE_READY,
		},
	}, {
		.state = UPGRADE_STATE_RO_UPGRADED,
		.next_size = 1,
		.next = {
			UPGRADE_STATE_RW_UPGRADING,
		},
	}, {
		.state = UPGRADE_STATE_RW_UPGRADING,
		.next_size = 3,
		.next = {
			UPGRADE_STATE_RW_UPGRADING,
			UPGRADE_STATE_RW_FAILED,
			UPGRADE_STATE_RW_UPGRADED,
		},
	}, {
		.state = UPGRADE_STATE_RW_FAILED,
		.next_size = 1,
		.next = {
			UPGRADE_STATE_READY,
		},
	}, {
		.state = UPGRADE_STATE_RW_UPGRADED,
		.next_size = 1,
		.next = {
			UPGRADE_STATE_COMPLETED,
		},
	}, {
		.state = UPGRADE_STATE_COMPLETED,
		.next_size = 1,
		.next = {
			UPGRADE_STATE_READY,
		},
	},
};

static size_t upgrade_states_len = sizeof(upgrade_states) / sizeof(upgrade_states[0]);

static struct upgrade_state *get_state_from_str(char *state_str)
{
	if (state_str == NULL)
		return NULL;

	size_t state_str_len = strlen(state_str);

	for (int i = 0; i < upgrade_states_len; ++i) {
		if (strncmp(upgrade_states[i].state, state_str, state_str_len + 1) != 0)
			continue;
		return &upgrade_states[i];
	}

	return NULL;
}

static int is_next_state_valid(char *current_state_str, char *next_state_str)
{
	if (current_state_str == NULL || next_state_str == NULL)
		return 0;

	struct upgrade_state *current_state = get_state_from_str(current_state_str);

	if (current_state == NULL)
		return 0;

	size_t next_state_str_len = strlen(next_state_str);

	for (int i = 0; i < current_state->next_size; ++i) {
		if (strncmp(current_state->next[i], next_state_str, next_state_str_len + 1) != 0)
			continue;
		return 1;
	}

	return 0;
}

int hal_device_board_set_upgrade_state(char *state_from, char *state_to)
{
	int ret;
	char current_state[128];

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->set_upgrade_state ||
	    !hal_device_board_funcs->get_upgrade_state)
		return -ENODEV;

	ret = hal_device_board_funcs->get_upgrade_state(current_state, sizeof(current_state));
	if (ret < 0)
		return ret;

	if (strncmp(current_state, state_from, strlen(state_from) + 1) != 0)
		return -EINVAL;

	if (!is_next_state_valid(state_from, state_to))
		return -EINVAL;

	return hal_device_board_funcs->set_upgrade_state(state_to);
}

int hal_device_board_get_upgrade_state(char *buffer, const int max_len)
{
	int ret;

	if (!hal_device_board_funcs) {
		if ((ret = hal_device_board_get_backend()) < 0)
			return ret;
	}

	if (!hal_device_board_funcs ||
	    !hal_device_board_funcs->get_upgrade_state)
		return -ENODEV;

	return hal_device_board_funcs->get_upgrade_state(buffer, max_len);
}