module-led.c

#include "globals.h"

#ifdef LEDSUPPORT

#include "module-led.h"
#include "oscam-string.h"
#include "oscam-time.h"

#if defined(__arm__)
struct s_arm_led
{
	int32_t led;
	int32_t action;
	time_t start_time;
};

static pthread_t arm_led_thread;
static LLIST *arm_led_actions;

#define ARM_LED_TYPES 3
#define ARM_LED_FILES 4

struct arm_leds
{
	char *machine;
	struct led_file
	{
		uint8_t id;
		char    *file;
	} leds[ARM_LED_FILES];
};

static const struct arm_leds arm_leds[ARM_LED_TYPES] =
{
	{
		"nslu2", {
			{ LED1A, "red:status" },
			{ LED1B, "green:ready" },
			{ LED2,  "green:disk-1" },
			{ LED3,  "green:disk-2" }
		},
	},
	{
		"dockstar", {
			{ LED1A, "orange:misc" },
			{ LED1B, "green:health" },
			{ LED2,  "green:health" },
			{ LED3,  "orange:misc" }
		},
	},
	{
		"wrt350nv2", {
			{ LED1A, "orange:power" },
			{ LED1B, "green:power" },
			{ LED2,  "green:wireless" },
			{ LED3,  "green:security" }
		},
	}
};

static int32_t arm_init_led_file(uint8_t led_type, uint8_t led_no, char *buf, int32_t buflen)
{
	uint8_t i;
	if(led_type >= ARM_LED_TYPES) { return 0; }
	if(led_no >= ARM_LED_FILES) { return 0; }
	for(i = 0; i < ARM_LED_FILES; i++)
	{
		if(arm_leds[led_type].leds[i].id == led_no)
		{
			return snprintf(buf, buflen, "/sys/class/leds/%s:%s/brightness",
							arm_leds[led_type].machine, arm_leds[led_type].leds[i].file);
		}
	}
	return 0;
}

#define LED_TYPE_UNKNOWN 0xff
static uint8_t arm_led_type = LED_TYPE_UNKNOWN;

static void arm_detect_led_type(void)
{
	uint8_t i;
	char led_file[256];
	for(i = 0; i < ARM_LED_TYPES; i++)
	{
		if(!arm_init_led_file(i, 0, led_file, sizeof(led_file)))
			{ break; }
		if(access(led_file, W_OK) == 0)
		{
			arm_led_type = i;
			cs_log("LED support for %s is activated.", arm_leds[arm_led_type].machine);
			break;
		}
	}
	if(arm_led_type == LED_TYPE_UNKNOWN)
		{ cs_log("LED support is not active. Can't detect machine type."); }
}

static void arm_switch_led_from_thread(int32_t led, int32_t action)
{
	if(action < 2)    // only LED_ON and LED_OFF
	{
		char led_file[256];
		if(!arm_init_led_file(arm_led_type, led, led_file, sizeof(led_file)))
			{ return; }
		FILE *f = fopen(led_file, "w");
		if(!f)
			{ return; }
		fprintf(f, "%d", action);
		fclose(f);
	}
	else     // LED Macros
	{
		switch(action)
		{
		case LED_DEFAULT:
			arm_switch_led_from_thread(LED1A, LED_OFF);
			arm_switch_led_from_thread(LED1B, LED_OFF);
			arm_switch_led_from_thread(LED2, LED_ON);
			arm_switch_led_from_thread(LED3, LED_OFF);
			break;
		case LED_BLINK_OFF:
			arm_switch_led_from_thread(led, LED_OFF);
			cs_sleepms(100);
			arm_switch_led_from_thread(led, LED_ON);
			break;
		case LED_BLINK_ON:
			arm_switch_led_from_thread(led, LED_ON);
			cs_sleepms(300);
			arm_switch_led_from_thread(led, LED_OFF);
			break;
		}
	}
}

static void *arm_led_thread_main(void *UNUSED(thread_data))
{
	uint8_t running = 1;
	set_thread_name(__func__);
	while(running)
	{
		LL_ITER iter = ll_iter_create(arm_led_actions);
		struct s_arm_led *arm_led;
		while((arm_led = ll_iter_next(&iter)))
		{
			int32_t led, action;
			time_t now, start;
			led = arm_led->led;
			action = arm_led->action;
			now = time((time_t)0);
			start = arm_led->start_time;
			ll_iter_remove_data(&iter);
			if(action == LED_STOP_THREAD)
			{
				running = 0;
				break;
			}
			if(now - start < ARM_LED_TIMEOUT)
			{
				arm_switch_led_from_thread(led, action);
			}
		}
		if(running)
		{
			sleep(60);
		}
	}
	ll_clear_data(arm_led_actions);
	pthread_exit(NULL);
	return NULL;
}

static void arm_led_start_thread(void)
{
	arm_detect_led_type();
	if(!cfg.enableled || arm_led_type == LED_TYPE_UNKNOWN)
		{ return; }
	// call this after signal handling is done
	if(!arm_led_actions)
	{
		arm_led_actions = ll_create("arm_led_actions");
	}
	pthread_attr_t attr;
	pthread_attr_init(&attr);
	cs_log("starting thread arm_led_thread");
	pthread_attr_setstacksize(&attr, PTHREAD_STACK_SIZE);
	int32_t ret = pthread_create(&arm_led_thread, &attr, arm_led_thread_main, NULL);
	if(ret)
	{
		cs_log("ERROR: can't create arm_led_thread thread (errno=%d %s)", ret, strerror(ret));
	}
	else
	{
		cs_log("arm_led_thread thread started");
		pthread_detach(arm_led_thread);
	}
	pthread_attr_destroy(&attr);
}

static void arm_led(int32_t led, int32_t action)
{
	struct s_arm_led *data;
	if(!cfg.enableled || arm_led_type == LED_TYPE_UNKNOWN)
		{ return; }
	if(!arm_led_actions)
	{
		arm_led_actions = ll_create("arm_led_actions");
	}
	if(cs_malloc(&data, sizeof(struct s_arm_led)))
	{
		data->start_time = time((time_t)0);
		data->led = led;
		data->action = action;
		ll_append(arm_led_actions, (void *)data);
	}
	if(arm_led_thread)
	{
		// arm_led_thread_main is not started at oscam startup
		// when first arm_led calls happen
		pthread_kill(arm_led_thread, OSCAM_SIGNAL_WAKEUP);
	}
}

static void arm_led_stop_thread(void)
{
	if(!cfg.enableled || arm_led_type == LED_TYPE_UNKNOWN)
		{ return; }
	arm_led(0, LED_STOP_THREAD);
}
#else
static inline void arm_led_start_thread(void) { }
static inline void arm_led_stop_thread(void) { }
static inline void arm_led(int32_t UNUSED(led), int32_t UNUSED(action)) { }
#endif


#ifdef QBOXHD
static void qboxhd_led_blink(int32_t color, int32_t duration)
{
	int32_t f;
	if(cfg.enableled != 2)
		{ return; }
	// try QboxHD-MINI first
	if((f = open(QBOXHDMINI_LED_DEVICE, O_RDWR | O_NONBLOCK)) > -1)
	{
		qboxhdmini_led_color_struct qbminiled;
		uint32_t qboxhdmini_color = 0x000000;
		if(color != QBOXHD_LED_COLOR_OFF)
		{
			switch(color)
			{
			case QBOXHD_LED_COLOR_RED:
				qboxhdmini_color = QBOXHDMINI_LED_COLOR_RED;
				break;
			case QBOXHD_LED_COLOR_GREEN:
				qboxhdmini_color = QBOXHDMINI_LED_COLOR_GREEN;
				break;
			case QBOXHD_LED_COLOR_BLUE:
				qboxhdmini_color = QBOXHDMINI_LED_COLOR_BLUE;
				break;
			case QBOXHD_LED_COLOR_YELLOW:
				qboxhdmini_color = QBOXHDMINI_LED_COLOR_YELLOW;
				break;
			case QBOXHD_LED_COLOR_MAGENTA:
				qboxhdmini_color = QBOXHDMINI_LED_COLOR_MAGENTA;
				break;
			}
			// set LED on with color
			qbminiled.red = (uchar)((qboxhdmini_color & 0xFF0000) >> 16); // R
			qbminiled.green = (uchar)((qboxhdmini_color & 0x00FF00) >> 8); // G
			qbminiled.blue = (uchar)(qboxhdmini_color & 0x0000FF);     // B
			ioctl(f, QBOXHDMINI_IOSET_RGB, &qbminiled);
			cs_sleepms(duration);
		}
		// set LED off
		qbminiled.red = 0;
		qbminiled.green = 0;
		qbminiled.blue = 0;
		ioctl(f, QBOXHDMINI_IOSET_RGB, &qbminiled);
		close(f);
	}
	else if((f = open(QBOXHD_LED_DEVICE, O_RDWR | O_NONBLOCK)) > -1)
	{
		qboxhd_led_color_struct qbled;
		if(color != QBOXHD_LED_COLOR_OFF)
		{
			// set LED on with color
			qbled.H = color;
			qbled.S = 99;
			qbled.V = 99;
			ioctl(f, QBOXHD_SET_LED_ALL_PANEL_COLOR, &qbled);
			cs_sleepms(duration);
		}
		// set LED off
		qbled.H = 0;
		qbled.S = 0;
		qbled.V = 0;
		ioctl(f, QBOXHD_SET_LED_ALL_PANEL_COLOR, &qbled);
		close(f);
	}
}
#else
static inline void qboxhd_led_blink(int32_t UNUSED(color), int32_t UNUSED(duration)) { }
#endif

void led_status_stopping(void)
{
	if(cfg.enableled == 1)
	{
		arm_led(LED1B, LED_OFF);
		arm_led(LED2,  LED_OFF);
		arm_led(LED3,  LED_OFF);
		arm_led(LED1A, LED_ON);
	}
	if(cfg.enableled == 2)
	{
		qboxhd_led_blink(QBOXHD_LED_COLOR_YELLOW,  QBOXHD_LED_BLINK_FAST);
		qboxhd_led_blink(QBOXHD_LED_COLOR_RED,     QBOXHD_LED_BLINK_FAST);
		qboxhd_led_blink(QBOXHD_LED_COLOR_GREEN,   QBOXHD_LED_BLINK_FAST);
		qboxhd_led_blink(QBOXHD_LED_COLOR_BLUE,    QBOXHD_LED_BLINK_FAST);
		qboxhd_led_blink(QBOXHD_LED_COLOR_MAGENTA, QBOXHD_LED_BLINK_FAST);
	}
}

void led_status_cw_not_found(ECM_REQUEST *er)
{
	if(!er->rc)
		{ arm_led(LED2, LED_BLINK_OFF); }
	if(er->rc < E_NOTFOUND)
	{
		qboxhd_led_blink(QBOXHD_LED_COLOR_GREEN, QBOXHD_LED_BLINK_MEDIUM);
	}
	else if(er->rc <= E_STOPPED)
	{
		qboxhd_led_blink(QBOXHD_LED_COLOR_RED, QBOXHD_LED_BLINK_MEDIUM);
	}
}

void led_status_default(void)
{
	arm_led(LED1A, LED_DEFAULT);
	arm_led(LED1A, LED_ON);
}

void led_status_starting(void)
{
	arm_led(LED1A, LED_OFF);
	arm_led(LED1B, LED_ON);
	qboxhd_led_blink(QBOXHD_LED_COLOR_YELLOW,  QBOXHD_LED_BLINK_FAST);
	qboxhd_led_blink(QBOXHD_LED_COLOR_RED,     QBOXHD_LED_BLINK_FAST);
	qboxhd_led_blink(QBOXHD_LED_COLOR_GREEN,   QBOXHD_LED_BLINK_FAST);
	qboxhd_led_blink(QBOXHD_LED_COLOR_BLUE,    QBOXHD_LED_BLINK_FAST);
	qboxhd_led_blink(QBOXHD_LED_COLOR_MAGENTA, QBOXHD_LED_BLINK_FAST);
}

void led_status_card_activation_error(void)
{
	qboxhd_led_blink(QBOXHD_LED_COLOR_MAGENTA, QBOXHD_LED_BLINK_MEDIUM);
}

void led_status_found_cardsystem(void)
{
	qboxhd_led_blink(QBOXHD_LED_COLOR_YELLOW, QBOXHD_LED_BLINK_MEDIUM);
	qboxhd_led_blink(QBOXHD_LED_COLOR_GREEN,  QBOXHD_LED_BLINK_MEDIUM);
	qboxhd_led_blink(QBOXHD_LED_COLOR_YELLOW, QBOXHD_LED_BLINK_MEDIUM);
	qboxhd_led_blink(QBOXHD_LED_COLOR_GREEN,  QBOXHD_LED_BLINK_MEDIUM);
}

void led_status_unsupported_card_system(void)
{
	qboxhd_led_blink(QBOXHD_LED_COLOR_MAGENTA, QBOXHD_LED_BLINK_MEDIUM);
}

void led_status_card_detected(void)
{
	qboxhd_led_blink(QBOXHD_LED_COLOR_YELLOW, QBOXHD_LED_BLINK_SLOW);
}

void led_status_card_ejected(void)
{
	qboxhd_led_blink(QBOXHD_LED_COLOR_RED, QBOXHD_LED_BLINK_SLOW);
}

void led_status_emm_ok(void)
{
	arm_led(LED3, LED_BLINK_ON);
	qboxhd_led_blink(QBOXHD_LED_COLOR_BLUE, QBOXHD_LED_BLINK_MEDIUM);
}

void led_init(void)
{
	arm_led_start_thread();
}

void led_stop(void)
{
	arm_led_stop_thread();
}

#endif