acs.c

/*
 * cntlr_acs.c - Auto Channel Selection
 *
 * Copyright (C) 2021 IOPSYS Software Solutions AB. All rights reserved.
 *
 */
#include "acs.h"

#include <easymesh.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <easy/easy.h>
#include <libubox/list.h>
#include <wifidefs.h>
#include <time.h>

#include "cntlr.h"
#include "cntlr_cmdu.h"
#include "cntlr_map.h"
#include "utils/debug.h"
#include "utils/utils.h"
#include "wifi_dataelements.h"
#include "wifi_opclass.h"
#include "timer.h"
#include "sta.h"

/* Per radio ACS recalc timer */
static void cntlr_radio_acs_timer(atimer_t *t);

/* Opclass helpers - move it to other place */
int cntlr_radio_pref_opclass_reset(struct wifi_radio_element *radio)
{
	/*
	 * Build initial preferred opclasses from supported opclasses
	 * we receive in basic radio capabilities.
	 */
	memcpy(&radio->pref_opclass, &radio->supp_opclass, sizeof(radio->pref_opclass));
	wifi_opclass_set_preferences(&radio->pref_opclass, 15 << 4);
	timestamp_update(&radio->pref_opclass.entry_time);

	return radio->pref_opclass.num_opclass;
}

enum wifi_radio_opclass_dfs dfs_state_from_preference(uint8_t preference)
{
	uint8_t reas = preference & CHANNEL_PREF_REASON;

	switch(reas) {
	case CHANNEL_PREF_REASON_DFS_USABLE:
		return WIFI_RADIO_OPCLASS_CHANNEL_DFS_USABLE;
	case CHANNEL_PREF_REASON_DFS_AVAILABLE:
		return WIFI_RADIO_OPCLASS_CHANNEL_DFS_AVAILABLE;
	case CHANNEL_PREF_REASON_DFS_NOP:
		return WIFI_RADIO_OPCLASS_CHANNEL_DFS_NOP;
	default:
		break;
	}

	return WIFI_RADIO_OPCLASS_CHANNEL_DFS_NONE;
}

int cntlr_radio_pref_opclass_add(struct wifi_radio_element *radio, uint8_t classid,
				 uint8_t channel, uint8_t preference)
{
	struct wifi_radio_opclass_entry *entry;
	struct wifi_radio_opclass_channel *chan;
	struct wifi_radio_opclass_channel new_chan = {};
	struct wifi_radio_opclass *opclass;

	opclass = &radio->pref_opclass;

	entry = wifi_opclass_find_entry(opclass, classid);
	if (!entry)
		return -1;

	entry->id = classid;
	entry->bandwidth = wifi_opclass_get_bw(classid);

	new_chan.channel = channel;
	new_chan.preference = preference;
	new_chan.dfs = dfs_state_from_preference(preference);

	timestamp_update(&opclass->entry_time);

	/* Don't clean cac_methods/cac_time */
	chan = wifi_opclass_find_channel(entry, channel);
	if (chan) {
		chan->channel = channel;
		chan->preference = preference;

		chan->dfs = dfs_state_from_preference(preference);

		return 0;
	}

	return wifi_opclass_add_channel(entry, &new_chan);
}

int cntlr_radio_pref_opclass_set_dfs_status(struct wifi_radio_element *radio, uint8_t classid,
					    uint8_t channel, enum wifi_radio_opclass_dfs state)
{
	struct wifi_radio_opclass_channel *chan;
	struct wifi_radio_opclass *opclass;

	opclass = &radio->pref_opclass;

	chan = wifi_opclass_get_channel(opclass, classid, channel);
	if (!chan)
		return -1;

	chan->dfs = state;
	return 0;
}

void cntlr_radio_pref_opclass_dump(struct wifi_radio_element *radio)
{
	wifi_opclass_dump(&radio->pref_opclass, "dev_pref_opclass", radio->macaddr);
}

void cntlr_radio_cur_opclass_reset(struct wifi_radio_element *radio)
{
	wifi_opclass_reset(&radio->cur_opclass);
}

int cntlr_radio_cur_opclass_add(struct wifi_radio_element *radio, uint8_t classid,
				uint8_t channel, uint8_t txpower)
{
	struct wifi_radio_opclass_entry *entry;
	struct wifi_radio_opclass_channel chan = {};

	entry = wifi_opclass_find_entry(&radio->cur_opclass, classid);
	if (!entry)
		entry = wifi_opclass_new_entry(&radio->cur_opclass);
	if (!entry)
		return -1;

	entry->id = classid;
	entry->bandwidth = wifi_opclass_get_bw(classid);
	entry->max_txpower = txpower;

	chan.channel = channel;
	chan.preference = 15 << 4;

	timestamp_update(&radio->cur_opclass.entry_time);
	return wifi_opclass_add_channel(entry, &chan);
}

uint8_t ctrl_radio_cur_opclass_id(struct wifi_radio_element *radio)
{
	uint8_t id = 0;
	int ret;

	ret = wifi_opclass_get_attr(&radio->cur_opclass, NULL, NULL, &id, NULL);
	if (ret)
		return 0;
	return id;
}

uint8_t ctrl_radio_cur_opclass_ctrl_chan(struct wifi_radio_element *radio)
{
	uint8_t ctrl_chan = 0;
	int ret;

	ret = wifi_opclass_get_attr(&radio->cur_opclass, &ctrl_chan, NULL, NULL, NULL);
	if (ret)
		return 0;
	return ctrl_chan;
}

uint8_t ctrl_radio_cur_opclass_chan(struct wifi_radio_element *radio)
{
	uint8_t chan = 0;
	int ret;

	ret = wifi_opclass_get_attr(&radio->cur_opclass, NULL, NULL, NULL, &chan);
	if (ret)
		return 0;
	return chan;
}

uint16_t ctrl_radio_cur_opclass_max_bw(struct wifi_radio_element *radio)
{
	uint32_t bw = 0;
	int ret;

	ret = wifi_opclass_get_attr(&radio->cur_opclass, NULL, &bw, NULL, NULL);
	if (ret)
		return 0;
	return bw;
}

void cntlr_radio_pref_opclass_set_pref(struct wifi_radio_element *radio, uint8_t id, uint8_t preference)
{
	wifi_opclass_id_set_preferences(&radio->pref_opclass, id, preference);
}

void cntlr_radio_cur_opclass_dump(struct wifi_radio_element *radio)
{
	wifi_opclass_dump(&radio->cur_opclass, "dev_cur_opclass", radio->macaddr);