path: root/cmd/cec.c

/*
 * Copyright
 *
 * Copyright (C) 2009-2010 Christian König (deathsimple@vodafone.de)
 *
 * License
 *
 * This program is free software; you can redistribute and/or modify
 * program under the terms of GNU General Public license either version 3
 * of the License, or (at your option) any later version. 
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <cec.h>

struct CEC_Device device;
enum CEC_Device_Type device_type = CEC_Playback_Device;

const char* usage =
"Usage: %s [commands]\n"
" -msp430 <device>			: use device as i2c device\n"
" -phys <?.?.?.?>			: use physical addr ?.?.?.?\n"
" -src <addr>				: use specified logical source addr\n"
" -addr <device type>			: run logical addr allocation algo\n"
" -ping <addr>				: ping addr\n"
" -standby <addr>			: put device into standby mode\n"
" -abort <addr>				: send abort command and wait for response\n"
" -audio-status <addr>			: send 'give audio status' and wait for response\n"
" -audio-mode <on/off>			: set system audio mode\n"
" -scan					: scan for active devices\n"
" -dump					: dump received cec packets\n"
" -active				: send Active Source packet\n"
" -decode <byte1> ...			: decode cec packet\n"
" -button <addr> <command> <duration>	: simulate a button press\n"
" -test <device2> <addr2>		: use a second device and adress to run a loopback test\n"
"\n\n";

void debug(enum CEC_Debug reason, struct CEC_Device* device, struct CEC_Packet* packet)
{
	switch(reason) {
	case CEC_RX_Packet:
		fprintf(stderr, "received   ");
		break;

	case CEC_TX_Success:
		fprintf(stderr, "succeeded  ");
		break;

	case CEC_TX_ERROR:
		fprintf(stderr, "io error   ");
		break;

	case CEC_TX_TIMEOUT:
		fprintf(stderr, "timeout    ");
		break;

	case CEC_TX_NACK:
		fprintf(stderr, "no ack     ");
		break;

	case CEC_TX_ARL:
		fprintf(stderr, "arbitation ");
		break;
	}
	CEC_Dump_Packet(stderr, packet);
	fprintf(stderr, "\n");
}

void handle_address(struct CEC_Device* device, struct CEC_Packet* packet)
{
	CEC_TX_Report_Physical_Address(device, device_type);
}

void handle_version(struct CEC_Device* device, struct CEC_Packet* packet)
{
	CEC_TX_Version(device, packet->src, CEC_Version_1_3a);
}

void handle_power_status(struct CEC_Device* device, struct CEC_Packet* packet)
{
	CEC_TX_Report_Power_Status(device, packet->src, CEC_Power_Status_On);
}

void init_device(struct CEC_Device* device, const char* hardware)
{
	CEC_Init_Device(device);
	device->hardware = MSP430_Open_Hardware(hardware);
	device->func_debug = debug;
	device->func_handler[CEC_Give_Physical_Address]		= handle_address;
	device->func_handler[CEC_Get_Version]			= handle_version;
	device->func_handler[CEC_Give_Device_Power_Status]	= handle_power_status;
}

void print_help(const char* progname, const char* message)
{
	if (message != NULL) fprintf(stderr, "%s\n", message);
	fprintf(stderr, usage, progname);
}

uint8_t parse_addr(int* i, int argc, const char* argv[])
{
	if (++(*i) == argc || !strncmp("-", argv[*i], 1)) {
		print_help(argv[0], "can't parse addr");
		exit(1);
	}
	return strtol(argv[*i], NULL, 0);
}

uint8_t parse_byte(int* i, int argc, const char* argv[])
{
	if (++(*i) == argc || !strncmp("-", argv[*i], 1)) {
		print_help(argv[0], "can't parse byte");
		exit(1);
	}
	return strtol(argv[*i], NULL, 0);
}

int parse_int(int* i, int argc, const char* argv[])
{
	if (++(*i) == argc || !strncmp("-", argv[*i], 1)) {
		print_help(argv[0], "can't parse int");
		exit(1);
	}
	return strtol(argv[*i], NULL, 0);
}

enum CEC_Device_Type parse_device_type(int* i, int argc, const char* argv[])
{
	if (++(*i) != argc) {
		if (!strncasecmp("TV", argv[*i], 3)) {
			return CEC_TV;
		} else if (!strncasecmp("Recorder", argv[*i], 10)) {
			return CEC_Recording_Device;

		} else if (!strncasecmp("Tuner", argv[*i], 6)) {
			return CEC_Tuner;

		} else if (!strncasecmp("Player", argv[*i], 9)) {
			return CEC_Playback_Device;

		} else if (!strncasecmp("Audio", argv[*i], 6)) {
			return CEC_Audio_System;
		}
	}
	print_help(argv[0], "can't parse device type");
	exit(1);
}

struct CEC_Physical_Address parse_physical(int* i, int argc, const char* argv[])
{
	if (++(*i) == argc || !strncmp("-", argv[*i], 1)) {
		print_help(argv[0], "can't parse physical address");
		exit(1);
	}

	int a,b,c,d;
	if(sscanf(argv[*i], "%i.%i.%i.%i", &a, &b, &c, &d) != 4) {
		print_help(argv[0], "can't parse physical address");
		exit(1);
	}
	
	struct CEC_Physical_Address addr = {
		.a = a,
		.b = b,
		.c = c,
		.d = d
	};
	return addr;
}

int parse_onoff(int* i, int argc, const char* argv[])
{
	if (++(*i) != argc) {
		if (!strncasecmp("on", argv[*i], 3)) {
			return 1;
		} else if (!strncasecmp("off", argv[*i], 4)) {
			return 0;
		}
	}
	print_help(argv[0], "can't parse on/off");
	exit(1);
}

void dump()
{
	while(1) {
		usleep(10000);
		CEC_Receive(&device);
	}
}

void test(const char* hardware, uint8_t addr)
{
	struct CEC_Device dst;

	init_device(&dst, hardware);
	dst.logical_address = addr;
	CEC_TX_Ping(&dst, dst.logical_address);

	while(1) {
		CEC_Receive(&device);
		CEC_Receive(&dst);
		//usleep(10000);

		struct CEC_Packet p;
		uint8_t* byte = ((uint8_t*)&p)+3;

		int count = random() % 16;
		for(p.length = 1; p.length<count; p.length++) {
			*byte++ = random();
		}

		p.dst = addr;
		p.src = device.logical_address;
		p.opcode = CEC_Abort;
		CEC_Transmit(&device, &p);
	}
}

int main(int argc, const char* argv[])
{
	int i;
	char addr;

	if(argc < 2) {
		print_help(argv[0], "Missing argument: please provide a command");
		return 1;
	}

	for(i=1; i<argc; i++) {

		if (!strncmp("-msp430", argv[i], 8)) {
			init_device(&device, argv[++i]);

		} else if (!strncmp("-phys", argv[i], 6)) {
			device.physical_address = parse_physical(&i, argc, argv);

		} else if (!strncmp("-src", argv[i], 5)) {
			device.logical_address = parse_addr(&i, argc, argv);
			CEC_TX_Ping(&device, device.logical_address);

		} else if (!strncmp("-ping", argv[i], 6)) {
			CEC_TX_Ping(&device, parse_addr(&i, argc, argv));

		} else if (!strncmp("-standby", argv[i], 9)) {
			CEC_TX_Standby(&device, parse_addr(&i, argc, argv));

		} else if (!strncmp("-abort", argv[i], 9)) {
			CEC_TX_Abort(&device, parse_addr(&i, argc, argv));
			dump();

		} else if (!strncmp("-audio-status", argv[i], 14)) {
			CEC_TX_Give_Audio_Status(&device, parse_addr(&i, argc, argv));
			dump();

		} else if (!strncmp("-audio-mode", argv[i], 12)) {
			CEC_TX_Set_System_Audio_Mode(&device, parse_onoff(&i, argc, argv));

		} else if (!strncmp("-scan", argv[i], 6)) {
			for(addr=0x0; addr<=0xF; addr++) {
				if(CEC_TX_Ping(&device, addr) == 0 && addr != 0xF) {
					CEC_TX_Give_Physical_Address(&device, addr);
				}
			}
			CEC_Receive(&device);

		} else if (!strncmp("-dump", argv[i], 6)) {
			dump();

		} else if (!strncmp("-active", argv[i], 8)) {
			CEC_TX_Active_Source(&device);

		} else if (!strncmp("-decode", argv[i], 8)) {
			struct CEC_Packet p;
			uint8_t* byte = ((uint8_t*)&p)+1;

			for(p.length = 0; p.length<=16; p.length++) {
				if (++i == argc || !strncmp("-", argv[i], 1)) 
					break;
				*byte++ = strtol(argv[i], NULL, 0);
			}
			
			CEC_Dump_Packet(stderr, &p);

		} else if (!strncmp("-button", argv[i], 8)) {
			addr = parse_addr(&i, argc, argv);
			uint8_t command = parse_byte(&i, argc, argv);
			int duration = parse_int(&i, argc, argv);

			CEC_TX_User_Control_Pressed(&device, addr, command);
			usleep(duration * 1000);
			CEC_TX_User_Control_Released(&device, addr);
			

		} else if (!strncmp("-addr", argv[i], 6)) {
			device_type = parse_device_type(&i, argc, argv);
			CEC_Alloc_Addr(&device, device_type);

		} else if (!strncmp("-test", argv[i], 6)) {
			const char* hw = argv[++i];
			test(hw, parse_addr(&i, argc, argv));

		} else {
			print_help(argv[0], "Unknown command");
		}
	}
	return 0;
}