int init_send_buffers(struct sb_config *sb, int buffer_size, int n_buffers)
{
void *ptr, *p;
int i;
memset(sb, 0, sizeof(struct sb_config));
if ((ptr = (void *)malloc((buffer_size * n_buffers))) == NULL)
return -1;
if ((sb->buffers =
(void *)malloc(sizeof(struct send_buffer) * n_buffers)) == NULL)
return -1;
for (i = 0, p = sb->buffers; i < n_buffers; ++i)
init_send_buffer((p + (i * sizeof(struct send_buffer))),
(ptr + (i * buffer_size)));
sb->buffer_size = buffer_size;
sb->n_buffers = n_buffers;
pthread_mutex_init(&(sb->lock), NULL);
return 0;
}
int init_send_buffers(struct sb_config *sb, unsigned int chunk_size, unsigned int chunks_in_a_buffer, unsigned int n_buffers)
{
void *ptr, *p;
unsigned int i;
if(chunks_in_a_buffer > MAX_CHUNKS_IN_A_BUFFER){
fprintf(stderr, "maximum chunks in a buffer is %u. given value %u is too big!\n", MAX_CHUNKS_IN_A_BUFFER, chunks_in_a_buffer);
return -1;
}
memset(sb, 0, sizeof(struct sb_config));
sb->buffer_size= (chunk_size * chunks_in_a_buffer);
sb->chunk_size= chunk_size;
sb->chunks_in_a_buffer= chunks_in_a_buffer;
sb->n_buffers = n_buffers;
if ((ptr = (void *)malloc((sb->buffer_size * n_buffers))) == NULL)
return -1;
if ((sb->buffers = (void *)malloc(sizeof(struct send_buffer) * n_buffers)) == NULL){
fprintf(stderr, "could not allocate memory for send buffers!\n");
return -1;
}
for (i = 0, p = sb->buffers; i < n_buffers; ++i)
init_send_buffer((p + (i * sizeof(struct send_buffer))),
(ptr + (i * sb->buffer_size)));
pthread_mutex_init(&(sb->lock), NULL);
return 0;
}
WL_API int init(HANDLE exitEvent) {
init_rec_buffer();
init_send_buffer();
initHardwareStruct();
threadExitEvent = exitEvent;
dataReadyEvent = CreateEvent(nullptr,TRUE,FALSE,nullptr);
sendReceiveData = new SendReceiveData();
if(!sendReceiveData->init()) return 0;
return 1;
}
WL_API int init(HANDLE exitEvent) {
init_rec_buffer();
init_send_buffer();
initHardwareStruct();
threadExitEvent = exitEvent;
dataReadyEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
sendReceiveData = new SendReceiveData();
if(!sendReceiveData->init()) return 0;
if(!sendReceiveData->setTransmitters(settings.getTransmitterChannels())) return 0;
return 1;
}
int default_init()
{
struct stat s;
int i;
/* FIXME: other modules might need this, too */
init_rec_buffer();
init_send_buffer();
if (stat(drv.device, &s) == -1) {
logprintf(LIRC_ERROR, "could not get file information for %s", drv.device);
logperror(LIRC_ERROR, "default_init()");
return (0);
}
/* file could be unix socket, fifo and native lirc device */
if (S_ISSOCK(s.st_mode)) {
struct sockaddr_un addr;
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, drv.device, sizeof(addr.sun_path) - 1);
drv.fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (drv.fd == -1) {
logprintf(LIRC_ERROR, "could not create socket");
logperror(LIRC_ERROR, "default_init()");
return (0);
}
if (connect(drv.fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
logprintf(LIRC_ERROR, "could not connect to unix socket %s", drv.device);
logperror(LIRC_ERROR, "default_init()");
default_deinit();
close(drv.fd);
return (0);
}
LOGPRINTF(1, "using unix socket lirc device");
drv.features = LIRC_CAN_REC_MODE2 | LIRC_CAN_SEND_PULSE;
drv.rec_mode = LIRC_MODE_MODE2; /* this might change in future */
drv.send_mode = LIRC_MODE_PULSE;
return (1);
}
if ((drv.fd = open(drv.device, O_RDWR)) < 0) {
logprintf(LIRC_ERROR, "could not open %s", drv.device);
logperror(LIRC_ERROR, "default_init()");
return (0);
}
if (S_ISFIFO(s.st_mode)) {
LOGPRINTF(1, "using defaults for the Irman");
drv.features = LIRC_CAN_REC_MODE2;
drv.rec_mode = LIRC_MODE_MODE2; /* this might change in future */
return (1);
} else if (!S_ISCHR(s.st_mode)) {
default_deinit();
logprintf(LIRC_ERROR, "%s is not a character device!!!", drv.device);
logperror(LIRC_ERROR, "something went wrong during installation");
return (0);
} else if (default_ioctl(LIRC_GET_FEATURES, &drv.features) == -1) {
logprintf(LIRC_ERROR, "could not get hardware features");
logprintf(LIRC_ERROR, "this device driver does not support the LIRC ioctl interface");
if (major(s.st_rdev) == 13) {
logprintf(LIRC_ERROR, "did you mean to use the devinput driver instead of the %s driver?",
drv.name);
} else {
logprintf(LIRC_ERROR, "major number of %s is %lu", drv.device, (__u32) major(s.st_rdev));
logprintf(LIRC_ERROR, "make sure %s is a LIRC device and use a current version of the driver",
drv.device);
}
default_deinit();
return (0);
}
else {
if (!(LIRC_CAN_SEND(drv.features) || LIRC_CAN_REC(drv.features))) {
LOGPRINTF(1, "driver supports neither sending nor receiving of IR signals");
}
if (LIRC_CAN_SEND(drv.features) && LIRC_CAN_REC(drv.features)) {
LOGPRINTF(1, "driver supports both sending and receiving");
} else if (LIRC_CAN_SEND(drv.features)) {
LOGPRINTF(1, "driver supports sending");
} else if (LIRC_CAN_REC(drv.features)) {
LOGPRINTF(1, "driver supports receiving");
}
}
/* set send/receive method */
drv.send_mode = 0;
if (LIRC_CAN_SEND(drv.features)) {
for (i = 0; supported_send_modes[i] != 0; i++) {
if (LIRC_CAN_SEND(drv.features) == supported_send_modes[i]) {
drv.send_mode = LIRC_SEND2MODE(supported_send_modes[i]);
break;
}
}
if (supported_send_modes[i] == 0) {
logprintf(LIRC_NOTICE, "the send method of the driver is not yet supported by lircd");
}
}
drv.rec_mode = 0;
if (LIRC_CAN_REC(drv.features)) {
for (i = 0; supported_rec_modes[i] != 0; i++) {
if (LIRC_CAN_REC(drv.features) == supported_rec_modes[i]) {
drv.rec_mode = LIRC_REC2MODE(supported_rec_modes[i]);
break;
}
}
if (supported_rec_modes[i] == 0) {
logprintf(LIRC_NOTICE, "the receive method of the driver is not yet supported by lircd");
}
}
if (drv.rec_mode == LIRC_MODE_MODE2) {
/* get resolution */
drv.resolution = 0;
if ((drv.features & LIRC_CAN_GET_REC_RESOLUTION)
&& (default_ioctl(LIRC_GET_REC_RESOLUTION, &drv.resolution) != -1)) {
LOGPRINTF(1, "resolution of receiver: %d", drv.resolution);
}
} else if (drv.rec_mode == LIRC_MODE_LIRCCODE) {
if (default_ioctl(LIRC_GET_LENGTH,
(void*) &drv.code_length) == -1) {
logprintf(LIRC_ERROR, "could not get code length");
logperror(LIRC_ERROR, "default_init()");
default_deinit();
return (0);
}
if (drv.code_length > sizeof(ir_code) * CHAR_BIT) {
logprintf(LIRC_ERROR, "lircd can not handle %lu bit codes", drv.code_length);
default_deinit();
return (0);
}
}
if (!(drv.send_mode || drv.rec_mode)) {
default_deinit();
return (0);
}
return (1);
}
int default_init()
{
#if defined(SIM_SEND) && !defined(DAEMONIZE)
hw.fd=STDOUT_FILENO;
hw.features=LIRC_CAN_SEND_PULSE;
hw.send_mode=LIRC_MODE_PULSE;
hw.rec_mode=0;
#elif defined(SIM_REC) && !defined(DAEMONIZE)
hw.fd=STDIN_FILENO;
hw.features=LIRC_CAN_REC_MODE2;
hw.send_mode=0;
hw.rec_mode=LIRC_MODE_MODE2;
#else
struct stat s;
int i;
/* FIXME: other modules might need this, too */
init_rec_buffer();
init_send_buffer();
if((hw.fd=open(hw.device,O_RDWR))<0)
{
logprintf(LOG_ERR,"could not open %s",hw.device);
logperror(LOG_ERR,"default_init()");
return(0);
}
if(fstat(hw.fd,&s)==-1)
{
default_deinit();
logprintf(LOG_ERR,"could not get file information");
logperror(LOG_ERR,"default_init()");
return(0);
}
if(S_ISFIFO(s.st_mode))
{
LOGPRINTF(1,"using defaults for the Irman");
hw.features=LIRC_CAN_REC_MODE2;
hw.rec_mode=LIRC_MODE_MODE2; /* this might change in future */
return(1);
}
else if(!S_ISCHR(s.st_mode))
{
default_deinit();
logprintf(LOG_ERR,"%s is not a character device!!!",
hw.device);
logperror(LOG_ERR,"something went wrong during "
"installation");
return(0);
}
else if(ioctl(hw.fd,LIRC_GET_FEATURES,&hw.features)==-1)
{
logprintf(LOG_ERR,"could not get hardware features");
logprintf(LOG_ERR,"this device driver does not "
"support the new LIRC interface");
logprintf(LOG_ERR,"make sure you use a current "
"version of the driver");
default_deinit();
return(0);
}
# ifdef DEBUG
else
{
if(!(LIRC_CAN_SEND(hw.features) ||
LIRC_CAN_REC(hw.features)))
{
LOGPRINTF(1,"driver supports neither "
"sending nor receiving of IR signals");
}
if(LIRC_CAN_SEND(hw.features) && LIRC_CAN_REC(hw.features))
{
LOGPRINTF(1,"driver supports both sending and "
"receiving");
}
else if(LIRC_CAN_SEND(hw.features))
{
LOGPRINTF(1,"driver supports sending");
}
else if(LIRC_CAN_REC(hw.features))
{
LOGPRINTF(1,"driver supports receiving");
}
}
# endif
/* set send/receive method */
hw.send_mode=0;
if(LIRC_CAN_SEND(hw.features))
{
for(i=0;supported_send_modes[i]!=0;i++)
{
if(hw.features&supported_send_modes[i])
{
unsigned long mode;
mode=LIRC_SEND2MODE(supported_send_modes[i]);
if(ioctl(hw.fd,LIRC_SET_SEND_MODE,&mode)==-1)
{
logprintf(LOG_ERR,"could not set "
"send mode");
logperror(LOG_ERR,"default_init()");
default_deinit();
return(0);
}
hw.send_mode=LIRC_SEND2MODE
(supported_send_modes[i]);
break;
}
}
if(supported_send_modes[i]==0)
{
logprintf(LOG_NOTICE,"the send method of the "
"driver is not yet supported by lircd");
}
}
hw.rec_mode=0;
if(LIRC_CAN_REC(hw.features))
{
for(i=0;supported_rec_modes[i]!=0;i++)
{
if(hw.features&supported_rec_modes[i])
{
unsigned long mode;
mode=LIRC_REC2MODE(supported_rec_modes[i]);
if(ioctl(hw.fd,LIRC_SET_REC_MODE,&mode)==-1)
{
logprintf(LOG_ERR,"could not set "
"receive mode");
logperror(LOG_ERR,"default_init()");
return(0);
}
hw.rec_mode=LIRC_REC2MODE
(supported_rec_modes[i]);
break;
}
}
if(supported_rec_modes[i]==0)
{
logprintf(LOG_NOTICE,"the receive method of the "
"driver is not yet supported by lircd");
}
}
if(hw.rec_mode==LIRC_MODE_CODE)
{
hw.code_length=8;
}
else if(hw.rec_mode==LIRC_MODE_LIRCCODE)
{
if(ioctl(hw.fd,LIRC_GET_LENGTH,&hw.code_length)==-1)
{
logprintf(LOG_ERR,"could not get code length");
logperror(LOG_ERR,"default_init()");
default_deinit();
return(0);
}
if(hw.code_length>sizeof(ir_code)*CHAR_BIT)
{
logprintf(LOG_ERR,"lircd can not handle %lu bit "
"codes",hw.code_length);
default_deinit();
return(0);
}
}
if(!(hw.send_mode || hw.rec_mode))
{
default_deinit();
return(0);
}
#endif
return(1);
}
static int uirt2_raw_init(void)
{
int version;
if (!tty_create_lock(hw.device)) {
logprintf(LOG_ERR, "uirt2_raw: could not create lock files");
return (0);
}
if ((hw.fd = open(hw.device, O_RDWR | O_NONBLOCK | O_NOCTTY)) < 0) {
logprintf(LOG_ERR, "uirt2_raw: could not open %s", hw.device);
tty_delete_lock();
return (0);
}
if (!tty_reset(hw.fd)) {
logprintf(LOG_ERR, "uirt2_raw: could not reset tty");
close(hw.fd);
tty_delete_lock();
return (0);
}
/* Wait for UIRT device to power up */
usleep(100 * 1000);
if (!tty_setbaud(hw.fd, 115200)) {
logprintf(LOG_ERR, "uirt2_raw: could not set baud rate");
close(hw.fd);
tty_delete_lock();
return (0);
}
if (!tty_setcsize(hw.fd, 8)) {
logprintf(LOG_ERR, "uirt2_raw: could not set csize");
close(hw.fd);
tty_delete_lock();
return (0);
}
if (!tty_setrtscts(hw.fd, 1)) {
logprintf(LOG_ERR, "uirt2_raw: could not enable hardware flow");
close(hw.fd);
tty_delete_lock();
return (0);
}
if ((dev = uirt2_init(hw.fd)) == NULL) {
logprintf(LOG_ERR, "uirt2_raw: No UIRT2 device found at %s", hw.device);
close(hw.fd);
tty_delete_lock();
return (0);
}
if (uirt2_setmoderaw(dev) < 0) {
logprintf(LOG_ERR, "uirt2_raw: could not set raw mode");
uirt2_raw_deinit();
return (0);
}
if (uirt2_getversion(dev, &version) < 0) {
uirt2_raw_deinit();
return (0);
}
if (version >= 0x0905) {
if (!tty_setdtr(hw.fd, 0)) {
logprintf(LOG_ERR, "uirt2_raw: could not set DTR");
uirt2_raw_deinit();
return (0);
}
}
init_rec_buffer();
init_send_buffer();
rec_rptr = 0;
rec_wptr = 0;
rec_size = sizeof(rec_buf) / sizeof(rec_buf[0]);
return (1);
}
