Attachment #342850 for bug #462596




dnl check if hiddev is available
AC_CHECK_HEADERS([linux/types.h])
AC_CHECK_HEADERS([linux/hiddev.h],[
  possible_drivers="${possible_drivers} (asusdh) (bw6130) (dvico) (macmini) (zotac)"
  AC_MSG_CHECKING(for HIDDEV_FLAG_UREF support)
  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <linux/types.h>

    ]])],[
    AC_MSG_RESULT(yes)
    AC_DEFINE(HAVE_LINUX_HIDDEV_FLAG_UREF)
    possible_drivers="${possible_drivers} (samsung) (sb0540) (zotac)"
    ],[
    AC_MSG_RESULT(no)
    ])

                          srm7500libusb, tekram,
                          tekram_bt829, tira, tira_raw, ttusbir,
                          tuxbox, tvbox, udp, uirt2, uirt2_raw,
                          usb_uirt_raw, usbx, wpc8769l, zotac],
driver=${withval},
driver="unset"
)

alsa_lib=""
atilibusb_lib=""
atwf83_lib=""
zotac_lib=""
awlibusb_lib=""
dfclibusb_lib=""
srm7500libusb_lib=""

	usbx)
		hw_module="${hw_module} hw_usbx.o serial.o"
		;;
	zotac)
		hw_module="${hw_module} hw_zotac.o"
		zotac_lib=-lpthread
		;;
  esac
  done
  #remove duplicates

  lircd_conf="creative/lircd.conf.alsa_usb"
fi

if test "$driver" = "zotac"; then
  lirc_driver="$driver"
  hw_module="hw_zotac.o"
  HW_DEFAULT="hw_zotac"
  lircd_conf="zotac/lircd.conf.zotac"
  zotac_lib=-lpthread
fi

if test "$driver" = "animax"; then
  lirc_driver="lirc_dev lirc_serial"
  lircd_conf="animax/lircd.conf.animax"

	test "$lirc_driver" = "macmini" || \
	test "$lirc_driver" = "samsung" || \
	test "$lirc_driver" = "sb0540" || \
	test "$lirc_driver" = "zotac" || \
	test "$lirc_driver" = "srm7500libusb" || \
	test "$lirc_driver" = "userspace"; then
  lirc_driver=

	receive="receive.o"
fi

hw_module_libs="${alsa_lib} ${atilibusb_lib} ${awlibusb_lib} ${caraca_lib} ${commandir_lib} ${dfclibusb_lib} ${ftdi_lib} ${iguanaIR_lib} ${irman_lib} ${portaudio_lib} ${srm7500libusb_lib} ${atwf83_lib} ${zotac_lib}"

dnl tell the Makefiles what we decided
AC_SUBST(daemon)

Lines 58-64 EXTRA_libhw_module_a_SOURCES = \ Link Here

(-)base/daemons/Makefile.am (-1 / +2 lines)
58	hw_usbx.c hw_usbx.h \	58	hw_usbx.c hw_usbx.h \
59	receive.c receive.h \	59	receive.c receive.h \
60	transmit.c transmit.h \	60	transmit.c transmit.h \
61	serial.c serial.h	61	serial.c serial.h \
		62	hw_zotac.c
62		63
63	libhw_module_a_LIBADD = @hw_module@	64	libhw_module_a_LIBADD = @hw_module@
64	libhw_module_a_DEPENDENCIES = @hw_module@	65	libhw_module_a_DEPENDENCIES = @hw_module@

Lines 59-64 extern struct hardware hw_uirt2; Link Here

(-)base/daemons/hw-types.c (+2 lines)
59	extern struct hardware hw_uirt2_raw;	59	extern struct hardware hw_uirt2_raw;
60	extern struct hardware hw_usb_uirt_raw;	60	extern struct hardware hw_usb_uirt_raw;
61	extern struct hardware hw_usbx;	61	extern struct hardware hw_usbx;
		62	extern struct hardware hw_zotac;
62		63
63	#ifndef HW_DEFAULT	64	#ifndef HW_DEFAULT
64	# define HW_DEFAULT hw_default	65	# define HW_DEFAULT hw_default
Lines 160-165 struct hardware *hw_list[] = { Link Here
160	#ifdef HAVE_LINUX_HIDDEV_FLAG_UREF	161	#ifdef HAVE_LINUX_HIDDEV_FLAG_UREF
161	&hw_samsung,	162	&hw_samsung,
162	&hw_sb0540,	163	&hw_sb0540,
		164	&hw_zotac,
163	#endif	165	#endif
164	&hw_silitek,	166	&hw_silitek,
165	#ifdef HAVE_LIBUSB	167	#ifdef HAVE_LIBUSB




/****************************************************************************
 ** hw_zotac.c *************************************************************
 ****************************************************************************
 *
 * Lirc driver for Zotac remote
 *
 * Copyright (C) 2010 Rainer Hochecker
 *
 * Distribute under GPL version 2 or later.
 *
 */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <stdio.h>
#include <pthread.h>
#include <sys/fcntl.h>
#include <signal.h>
#include <linux/hiddev.h>
#include <sys/ioctl.h>
#include "hardware.h"
#include "ir_remote.h"
#include "lircd.h"

enum {
	RPT_NO = 0,
	RPT_YES = 1,
};

static int zotac_init();
static int zotac_deinit();
static char *zotac_rec(struct ir_remote *remotes);
static int zotac_decode(struct ir_remote *remote, ir_code * prep, ir_code * codep, ir_code * postp, int *repeat_flagp,
			 lirc_t * min_remaining_gapp, lirc_t * max_remaining_gapp);
static void *zotac_repeat();
static int zotac_getcode();

/** Max number of repetitions */
const unsigned max_repeat_count = 500;
/** Code that triggers key release */
const unsigned release_code = 0x00000000;
/** Code that triggers device remove  */
const unsigned remove_code =0x00FFFFFF;
/** Time to wait before first repetition */
const unsigned repeat_time1_us = 500000;
/** Time to wait between two repetitions */
const unsigned repeat_time2_us = 100000;
/** Pipe between main thread and repetition thread */
static int fd_pipe[2] = { -1, -1 };

/** Thread that simulates repetitions */
static pthread_t repeat_thread;
/** File descriptor for the real device */
static int fd_hidraw;

const int main_code_length = 32;
static signed int main_code = 0;
static struct timeval start, end, last;
static int repeat_state = RPT_NO;
static int error_state = 0;
static int probe_code = 0;

#ifdef HAVE_LINUX_HIDDEV_FLAG_UREF
/* Zotac USB iR Receiver */
struct hardware hw_zotac = {
	"/dev/usb/hiddev0",		/* "device" */
	-1,			/* fd (device) */
	LIRC_CAN_REC_LIRCCODE,	/* features */
	0,			/* send_mode */
	LIRC_MODE_LIRCCODE,	/* rec_mode */
	32,			/* code_length */
	zotac_init,		/* init_func */
	zotac_deinit,		/* deinit_func */
	NULL,			/* send_func */
	zotac_rec,		/* rec_func */
	zotac_decode,		/* decode_func */
	NULL,			/* ioctl_func */
	NULL,			/* readdata */
	"zotac"		/* name */
};
#endif

static int zotac_decode(struct ir_remote *remote, ir_code * prep, ir_code * codep, ir_code * postp, int *repeat_flagp,
		  lirc_t * min_remaining_gapp, lirc_t * max_remaining_gapp)
{
	LOGPRINTF(1, "zotac_decode");

	if (!map_code(remote, prep, codep, postp, 0, 0, main_code_length, main_code, 0, 0)) {
		return 0;
	}

	map_gap(remote, &start, &last, 0, repeat_flagp, min_remaining_gapp, max_remaining_gapp);
	/* override repeat */
	*repeat_flagp = repeat_state;

	return 1;
}

static int zotac_getcode() {

	ssize_t rd;
	struct hiddev_usage_ref uref;
	struct hiddev_report_info rinfo;
	struct hiddev_field_info finfo;
	int shift = 0;

	rd = read(fd_hidraw, &uref, sizeof(uref));
	if (rd < 0) {
		logprintf(LOG_ERR, "error reading '%s'", hw.device);
		logperror(LOG_ERR, NULL);
		zotac_deinit();
		error_state = 1;
		return -1;
	}

	if (uref.field_index == HID_FIELD_INDEX_NONE) {
		/*
		 * we get this when the new report has been send from
		 * device at this point we have the uref structure
		 * prefilled with correct report type and id
		 *
		 */

		switch (uref.report_id) {
		case 1:	/* USB standard keyboard usage page */
			{
				/* This page reports cursor keys */
				LOGPRINTF(3, "Keyboard (standard)\n");

				/* check for special codes */
				uref.field_index = 0;
				uref.usage_index = 1;
				/* fetch the usage code for given indexes */
				ioctl(fd_hidraw, HIDIOCGUCODE, &uref, sizeof(uref));
				/* fetch the value from report */
				ioctl(fd_hidraw, HIDIOCGUSAGE, &uref, sizeof(uref));

				if (uref.value)
					shift = 1;

				/* populate required field number */
				uref.field_index = 1;
				uref.usage_index = 0;
				/* fetch the usage code for given indexes */
				ioctl(fd_hidraw, HIDIOCGUCODE, &uref, sizeof(uref));
				/* fetch the value from report */
				ioctl(fd_hidraw, HIDIOCGUSAGE, &uref, sizeof(uref));
				/* now we have the key */

				LOGPRINTF(3, "usage: %x   value: %x   shift: %d\n",uref.usage_code, uref.value, shift);

				/* now we have the key */
				if (uref.value) {
					probe_code = (uref.usage_code | uref.value);
					if (shift)
						probe_code |= 0x10000000;
					LOGPRINTF(3, "Main code 1: %x\n", probe_code);
					return 1;
				}
				else {
					LOGPRINTF(3, "rel button\n");
					probe_code = release_code;
					return 2;
				}
			}
			break;

		case 2:
		case 3:	/* USB generic desktop usage page */
		case 4:
			{
				/* This page reports power key
				 * (via SystemControl SLEEP)
				 */
				LOGPRINTF(3, "Generic desktop (standard)\n");


				/* traverse report descriptor */
				rinfo.report_type = HID_REPORT_TYPE_INPUT;
				rinfo.report_id = HID_REPORT_ID_FIRST;
				rd = ioctl(fd_hidraw, HIDIOCGREPORTINFO, &rinfo);

				unsigned int i,j;
				while (rd >= 0) {
					for (i = 0; i < rinfo.num_fields; i++) {
						finfo.report_type = rinfo.report_type;
				        finfo.report_id = rinfo.report_id;
				        finfo.field_index = i;
				        ioctl(fd_hidraw, HIDIOCGFIELDINFO, &finfo);
				        for (j = 0; j < finfo.maxusage; j++) {
				        	uref.field_index = i;
				            uref.usage_index = j;
				            ioctl(fd_hidraw, HIDIOCGUCODE, &uref);
				            ioctl(fd_hidraw, HIDIOCGUSAGE, &uref);

				            if (uref.value != 0) {
				            	LOGPRINTF(3, "field: %d, idx: %d, usage: %x   value: %x\n",i, j, uref.usage_code, uref.value);
				            	probe_code = uref.usage_code;
				            	return 1;
				            }
				        }
					}
					rinfo.report_id |= HID_REPORT_ID_NEXT;
				 	rd = ioctl(fd_hidraw, HIDIOCGREPORTINFO, &rinfo);
				}
				return 2;
			}
			break;
		default:
			/* Unknown/unsupported report id.
			 * Should not happen because remaining reports
			 * from report descriptor seem to be unused by remote.
			 */
			logprintf(LOG_ERR, "Unexpected report id %d", uref.report_id);
			break;
		}
	}
	else {
			/* This page reports power key
			 * (via SystemControl SLEEP)
			 */
			LOGPRINTF(3, "Same Event ...\n");

			/* traverse report descriptor */
			rinfo.report_type = HID_REPORT_TYPE_INPUT;
			rinfo.report_id = HID_REPORT_ID_FIRST;
			rd = ioctl(fd_hidraw, HIDIOCGREPORTINFO, &rinfo);

			unsigned int i,j;
			while (rd >= 0) {
				for (i = 0; i < rinfo.num_fields; i++) {
					finfo.report_type = rinfo.report_type;
				    finfo.report_id = rinfo.report_id;
				    finfo.field_index = i;
				    ioctl(fd_hidraw, HIDIOCGFIELDINFO, &finfo);
				    for (j = 0; j < finfo.maxusage; j++) {
				       	uref.field_index = i;
				        uref.usage_index = j;
				        ioctl(fd_hidraw, HIDIOCGUCODE, &uref);
				        ioctl(fd_hidraw, HIDIOCGUSAGE, &uref);

				        if (uref.value != 0) {
				         	LOGPRINTF(3, "usage: %x   value: %x\n",uref.usage_code, uref.value);
				          	//probe_code = uref.usage_code;
				          	return 0;
						}
					}
				}
				rinfo.report_id |= HID_REPORT_ID_NEXT;
			 	rd = ioctl(fd_hidraw, HIDIOCGREPORTINFO, &rinfo);
			}
			return 2;
	}
	return 0;
}

static int zotac_init()
{
	logprintf(LOG_INFO, "zotac initializing '%s'", hw.device);
	if ((fd_hidraw = open(hw.device, O_RDONLY)) < 0) {
		logprintf(LOG_ERR, "unable to open '%s'", hw.device);
		return 0;
	}
	int flags = HIDDEV_FLAG_UREF | HIDDEV_FLAG_REPORT;
	if (ioctl(fd_hidraw, HIDIOCSFLAG, &flags)) {
		return 0;
	}
	hw.fd = fd_hidraw;

	/* Create pipe so that events sent by the repeat thread will
	   trigger main thread */
	if (pipe(fd_pipe) != 0) {
		logperror(LOG_ERR, "couldn't open pipe");
		close(fd_hidraw);
		return 0;
	}
	hw.fd = fd_pipe[0];
	/* Create thread to simulate repetitions */
	if (pthread_create(&repeat_thread, NULL, zotac_repeat, NULL)) {
		logprintf(LOG_ERR, "Could not create \"repeat thread\"");
		return 0;
	}
	return 1;
}

static int zotac_deinit()
{
	pthread_cancel(repeat_thread);
	if (fd_hidraw != -1) {
		// Close device if it is open
		logprintf(LOG_INFO, "closing '%s'", hw.device);
		close(fd_hidraw);
		fd_hidraw = -1;
	}
	// Close pipe input
	if (fd_pipe[1] >= 0) {
		close(fd_pipe[1]);
		fd_pipe[1] = -1;
	}
	// Close pipe output
	if (fd_pipe[0] >= 0) {
		close(fd_pipe[0]);
		fd_pipe[0] = -1;
	}
	hw.fd = -1;
	return 1;
}

/**
 *	Runtime that reads device, forwards codes to main thread
 *	and simulates repetitions.
 */
static void *zotac_repeat()
{
	int repeat_count = 0;
	unsigned current_code;
	int ret;
	int sel;
	fd_set files;
	struct timeval delay;
	int pressed = 0;
	int fd = fd_pipe[1];

	while (1) {
		// Initialize set to monitor device's events
		FD_ZERO(&files);
		FD_SET(fd_hidraw, &files);
		if (pressed) {
			sel = select(FD_SETSIZE, &files, NULL, NULL, &delay);
		} else {
			sel = select(FD_SETSIZE, &files, NULL, NULL, NULL);
		}

		switch (sel) {
		case 1:
			// Data ready in device's file
			ret = zotac_getcode();

			if (ret < 0) {
				// Error
				logprintf(LOG_ERR, "(%s) Could not read %s", __FUNCTION__, hw.device);
				goto exit_loop;
			}
			if (ret == 1) {
				// Key code : forward it to main thread
				pressed = 1;
				repeat_count = 0;
				delay.tv_sec = 0;
				delay.tv_usec = repeat_time1_us;
				current_code = probe_code;
			} else if (ret == 2) {
				// Release code : stop repetitions
				pressed = 0;
				current_code = release_code;
			} else if (ret == 0) {
				continue;
			}
			break;
		case 0:
			repeat_count++;
			if (repeat_count >= max_repeat_count) {
				// Too many repetitions, something must have gone wrong
				logprintf(LOG_ERR,"(%s) too many repetitions", __FUNCTION__);
				goto exit_loop;
			}
			// Timeout : send current_code again to main
			//           thread to simulate repetition
			delay.tv_sec = 0;
			delay.tv_usec = repeat_time2_us;
			break;
		default:
			// Error
			logprintf(LOG_ERR, "(%s) select() failed", __FUNCTION__);
			goto exit_loop;
		}
		// Send code to main thread through pipe
		write(fd, &current_code, sizeof(current_code));
	}
exit_loop:

	// Wake up main thread with special key code
	current_code = remove_code;
	write(fd, &current_code, sizeof(current_code));
	return NULL;
}

/*
*  Aureal Technology ATWF@83 cheap remote
*  specific code.
*/

static char *zotac_rec(struct ir_remote *remotes)
{
	unsigned ev;
	int rd;
	last = end;
	gettimeofday(&start, NULL);
	rd = read(hw.fd, &ev, sizeof(ev));

	if (rd == -1) {
		// Error
		logprintf(LOG_ERR, "(%s) could not read pipe", __FUNCTION__);
		zotac_deinit();
		return 0;
	}

	if (ev == release_code) {
		// Release code
		main_code = 0;
		return 0;
	} else if (ev == remove_code) {
		// Device has been removed
		zotac_deinit();
		return 0;
	}

	LOGPRINTF(1, "zotac : %x", ev);
	// Record the code and check for repetition
	if (main_code == ev) {
		repeat_state = RPT_YES;
	} else {
		main_code = ev;
		repeat_state = RPT_NO;
	}
	gettimeofday(&end, NULL);
	return decode_all(remotes);
}





# Please make this file available to others
# by sending it to <lirc@bartelmus.de>
#
# this config file was automatically generated
# using lirc-0.9.1-git(zotac) on Mon Apr  2 14:10:29 2012
#
# contributed by 
#
# brand:                       zotac.conf
# model no. of remote control: 
# devices being controlled by this remote:
#

begin remote

  name  zotac.conf
  bits           32
  eps            30
  aeps          100

  one             0     0
  zero            0     0
  gap          100123
  min_repeat      9
#  suppress_repeat 9
#  uncomment to suppress unwanted repeats
#  toggle_bit_mask 0x7004F

      begin codes
          KEY_SLEEP                0x00010082
          KEY_WAKEUP               0x00010083
          KEY_RECORD               0x000C00B2
          KEY_PAUSE                0x000C00B1
          KEY_STOP                 0x000C00B7
          KEY_REWIND               0x000C00B4
          KEY_PLAY                 0x000C00B0
          KEY_FORWARD              0x000C00B3
          KEY_LEFTSHIFT            0x000C00B6
          KEY_RIGHTSHIFT           0x000C00B5
          KEY_BACK                 0x000C0224
          KEY_INFO                 0x000C0209
          KEY_MENU                 0xFFBC000D
          KEY_UP                   0x00070052
          KEY_LEFT                 0x00070050
          KEY_RIGHT                0x0007004F
          KEY_DOWN                 0x00070051
          KEY_OK                   0x00070028
          KEY_VOLUMEUP             0x000C00E9
          KEY_VOLUMEDOWN           0x000C00EA
          KEY_MUTE                 0x000C00E2
          KEY_CHANNELUP            0x000C009C
          KEY_CHANNELDOWN          0x000C009D
          KEY_1                    0x0007001E
          KEY_2                    0x0007001F
          KEY_3                    0x00070020
          KEY_4                    0x00070021
          KEY_5                    0x00070022
          KEY_6                    0x00070023
          KEY_7                    0x00070024
          KEY_8                    0x00070025
          KEY_9                    0x00070026
          KEY_0                    0x00070027
          KEY_NUMERIC_STAR         0x10070025
          KEY_NUMERIC_POUND        0x10070020
          KEY_CLEAR                0x00070029
          KEY_TEXT                 0xFFBC005A
          KEY_TITLE                0x000C008D
          KEY_ENTER                0x00070028
          KEY_RED                  0xFFBC005B
          KEY_GREEN                0xFFBC005C
          KEY_YELLOW               0xFFBC005D
          KEY_BLUE                 0xFFBC005E
      end codes

end remote





	usb_uirt_raw: "USB-UIRT"
	mplay: "VLSystem MPlay Blast"
	mplay: "VLSystem MPlay Mini"
	zotac: "Zotac USB IR Receiver"

param_type: \
	act200l \

	ttusbir \
	tvbox \
	udp \
	wpc8769l \
	zotac
	none:

default_param: \

	ttusbir \
	tvbox \
	udp \
	wpc8769l \
	zotac
	none:

default_param: \

Return to bug 462596

Lines 383-389 AC_CHECK_HEADERS(linux/input.h,[ Link Here

(-)base/configure.ac (-4 / +18 lines)
383	dnl check if hiddev is available	383	dnl check if hiddev is available
384	AC_CHECK_HEADERS([linux/types.h])	384	AC_CHECK_HEADERS([linux/types.h])
385	AC_CHECK_HEADERS([linux/hiddev.h],[	385	AC_CHECK_HEADERS([linux/hiddev.h],[
386	possible_drivers="${possible_drivers} (asusdh) (bw6130) (dvico) (macmini)"	386	possible_drivers="${possible_drivers} (asusdh) (bw6130) (dvico) (macmini) (zotac)"
387	AC_MSG_CHECKING(for HIDDEV_FLAG_UREF support)	387	AC_MSG_CHECKING(for HIDDEV_FLAG_UREF support)
388	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[	388	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
389	#include <linux/types.h>	389	#include <linux/types.h>
Lines 393-399 AC_CHECK_HEADERS([linux/hiddev.h],[ Link Here
393	]])],[	393	]])],[
394	AC_MSG_RESULT(yes)	394	AC_MSG_RESULT(yes)
395	AC_DEFINE(HAVE_LINUX_HIDDEV_FLAG_UREF)	395	AC_DEFINE(HAVE_LINUX_HIDDEV_FLAG_UREF)
396	possible_drivers="${possible_drivers} (samsung) (sb0540)"	396	possible_drivers="${possible_drivers} (samsung) (sb0540) (zotac)"
397	],[	397	],[
398	AC_MSG_RESULT(no)	398	AC_MSG_RESULT(no)
399	])	399	])
Lines 446-452 AC_ARG_WITH(driver, Link Here
446	srm7500libusb, tekram,	446	srm7500libusb, tekram,
447	tekram_bt829, tira, tira_raw, ttusbir,	447	tekram_bt829, tira, tira_raw, ttusbir,
448	tuxbox, tvbox, udp, uirt2, uirt2_raw,	448	tuxbox, tvbox, udp, uirt2, uirt2_raw,
449	usb_uirt_raw, usbx, wpc8769l],	449	usb_uirt_raw, usbx, wpc8769l, zotac],
450	driver=${withval},	450	driver=${withval},
451	driver="unset"	451	driver="unset"
452	)	452	)
Lines 464-469 portaudio_lib="" Link Here
464	alsa_lib=""	464	alsa_lib=""
465	atilibusb_lib=""	465	atilibusb_lib=""
466	atwf83_lib=""	466	atwf83_lib=""
		467	zotac_lib=""
467	awlibusb_lib=""	468	awlibusb_lib=""
468	dfclibusb_lib=""	469	dfclibusb_lib=""
469	srm7500libusb_lib=""	470	srm7500libusb_lib=""
Lines 683-688 if test "$driver" = "userspace" -o "$dri Link Here
683	usbx)	684	usbx)
684	hw_module="${hw_module} hw_usbx.o serial.o"	685	hw_module="${hw_module} hw_usbx.o serial.o"
685	;;	686	;;
		687	zotac)
		688	hw_module="${hw_module} hw_zotac.o"
		689	zotac_lib=-lpthread
		690	;;
686	esac	691	esac
687	done	692	done
688	#remove duplicates	693	#remove duplicates
Lines 733-738 if test "$driver" = "alsa_usb"; then Link Here
733	lircd_conf="creative/lircd.conf.alsa_usb"	738	lircd_conf="creative/lircd.conf.alsa_usb"
734	fi	739	fi
735		740
		741	if test "$driver" = "zotac"; then
		742	lirc_driver="$driver"
		743	hw_module="hw_zotac.o"
		744	HW_DEFAULT="hw_zotac"
		745	lircd_conf="zotac/lircd.conf.zotac"
		746	zotac_lib=-lpthread
		747	fi
		748
736	if test "$driver" = "animax"; then	749	if test "$driver" = "animax"; then
737	lirc_driver="lirc_dev lirc_serial"	750	lirc_driver="lirc_dev lirc_serial"
738	lircd_conf="animax/lircd.conf.animax"	751	lircd_conf="animax/lircd.conf.animax"
Lines 1499-1504 if test "$lirc_driver" = "none" \|\| \ Link Here
1499	test "$lirc_driver" = "macmini" \|\| \	1512	test "$lirc_driver" = "macmini" \|\| \
1500	test "$lirc_driver" = "samsung" \|\| \	1513	test "$lirc_driver" = "samsung" \|\| \
1501	test "$lirc_driver" = "sb0540" \|\| \	1514	test "$lirc_driver" = "sb0540" \|\| \
		1515	test "$lirc_driver" = "zotac" \|\| \
1502	test "$lirc_driver" = "srm7500libusb" \|\| \	1516	test "$lirc_driver" = "srm7500libusb" \|\| \
1503	test "$lirc_driver" = "userspace"; then	1517	test "$lirc_driver" = "userspace"; then
1504	lirc_driver=	1518	lirc_driver=
Lines 1669-1675 if ! echo ${hw_module}\|grep " receive.o" Link Here
1669	receive="receive.o"	1683	receive="receive.o"
1670	fi	1684	fi
1671		1685
1672	hw_module_libs="${alsa_lib} ${atilibusb_lib} ${awlibusb_lib} ${caraca_lib} ${commandir_lib} ${dfclibusb_lib} ${ftdi_lib} ${iguanaIR_lib} ${irman_lib} ${portaudio_lib} ${srm7500libusb_lib} ${atwf83_lib}"	1686	hw_module_libs="${alsa_lib} ${atilibusb_lib} ${awlibusb_lib} ${caraca_lib} ${commandir_lib} ${dfclibusb_lib} ${ftdi_lib} ${iguanaIR_lib} ${irman_lib} ${portaudio_lib} ${srm7500libusb_lib} ${atwf83_lib} ${zotac_lib}"
1673		1687
1674	dnl tell the Makefiles what we decided	1688	dnl tell the Makefiles what we decided
1675	AC_SUBST(daemon)	1689	AC_SUBST(daemon)

Lines 146-151 hw_menu_entry: @hw-usb Link Here

(-)base/setup.data (-2 / +5 lines)
146	usb_uirt_raw: "USB-UIRT"	146	usb_uirt_raw: "USB-UIRT"
147	mplay: "VLSystem MPlay Blast"	147	mplay: "VLSystem MPlay Blast"
148	mplay: "VLSystem MPlay Mini"	148	mplay: "VLSystem MPlay Mini"
		149	zotac: "Zotac USB IR Receiver"
149		150
150	param_type: \	151	param_type: \
151	act200l \	152	act200l \
Lines 260-266 param_type: \ Link Here
260	ttusbir \	261	ttusbir \
261	tvbox \	262	tvbox \
262	udp \	263	udp \
263	wpc8769l	264	wpc8769l \
		265	zotac
264	none:	266	none:
265		267
266	default_param: \	268	default_param: \
Lines 331-337 default_param: \ Link Here
331	ttusbir \	333	ttusbir \
332	tvbox \	334	tvbox \
333	udp \	335	udp \
334	wpc8769l	336	wpc8769l \
		337	zotac
335	none:	338	none:
336		339
337	default_param: \	340	default_param: \

Line 0 Link Here

(-)base/daemons/hw_zotac.c (+429 lines)
		1	/****************************************************************************
		2	hw_zotac.c ***********************************************************
		3	****************************************************************************
		4	*
		5	* Lirc driver for Zotac remote
		6	*
		7	* Copyright (C) 2010 Rainer Hochecker
		8	*
		9	* Distribute under GPL version 2 or later.
		10	*
		11	*/
		12
		13	#ifdef HAVE_CONFIG_H
		14	# include <config.h>
		15	#endif
		16
		17	#include <stdio.h>
		18	#include <pthread.h>
		19	#include <sys/fcntl.h>
		20	#include <signal.h>
		21	#include <linux/hiddev.h>
		22	#include <sys/ioctl.h>
		23	#include "hardware.h"
		24	#include "ir_remote.h"
		25	#include "lircd.h"
		26
		27	enum {
		28	RPT_NO = 0,
		29	RPT_YES = 1,
		30	};
		31
		32	static int zotac_init();
		33	static int zotac_deinit();
		34	static char zotac_rec(struct ir_remote remotes);
		35	static int zotac_decode(struct ir_remote remote, ir_code prep, ir_code * codep, ir_code * postp, int *repeat_flagp,
		36	lirc_t * min_remaining_gapp, lirc_t * max_remaining_gapp);
		37	static void *zotac_repeat();
		38	static int zotac_getcode();
		39
		40	/** Max number of repetitions */
		41	const unsigned max_repeat_count = 500;
		42	/** Code that triggers key release */
		43	const unsigned release_code = 0x00000000;
		44	/** Code that triggers device remove */
		45	const unsigned remove_code =0x00FFFFFF;
		46	/** Time to wait before first repetition */
		47	const unsigned repeat_time1_us = 500000;
		48	/** Time to wait between two repetitions */
		49	const unsigned repeat_time2_us = 100000;
		50	/** Pipe between main thread and repetition thread */
		51	static int fd_pipe[2] = { -1, -1 };
		52
		53	/** Thread that simulates repetitions */
		54	static pthread_t repeat_thread;
		55	/** File descriptor for the real device */
		56	static int fd_hidraw;
		57
		58	const int main_code_length = 32;
		59	static signed int main_code = 0;
		60	static struct timeval start, end, last;
		61	static int repeat_state = RPT_NO;
		62	static int error_state = 0;
		63	static int probe_code = 0;
		64
65	#ifdef HAVE_LINUX_HIDDEV_FLAG_UREF
66	/* Zotac USB iR Receiver */
67	struct hardware hw_zotac = {
68	"/dev/usb/hiddev0", /* "device" */
69	-1, /* fd (device) */
70	LIRC_CAN_REC_LIRCCODE, /* features */
71	0, /* send_mode */
72	LIRC_MODE_LIRCCODE, /* rec_mode */
73	32, /* code_length */
74	zotac_init, /* init_func */
75	zotac_deinit, /* deinit_func */
76	NULL, /* send_func */
77	zotac_rec, /* rec_func */
78	zotac_decode, /* decode_func */
79	NULL, /* ioctl_func */
80	NULL, /* readdata */
81	"zotac" /* name */
82	};
83	#endif
84
85	static int zotac_decode(struct ir_remote remote, ir_code prep, ir_code * codep, ir_code * postp, int *repeat_flagp,
86	lirc_t * min_remaining_gapp, lirc_t * max_remaining_gapp)
87	{
88	LOGPRINTF(1, "zotac_decode");
89
90	if (!map_code(remote, prep, codep, postp, 0, 0, main_code_length, main_code, 0, 0)) {
91	return 0;
92	}
93
94	map_gap(remote, &start, &last, 0, repeat_flagp, min_remaining_gapp, max_remaining_gapp);
95	/* override repeat */
96	*repeat_flagp = repeat_state;
97
98	return 1;
99	}
100
101	static int zotac_getcode() {
102
103	ssize_t rd;
104	struct hiddev_usage_ref uref;
105	struct hiddev_report_info rinfo;
106	struct hiddev_field_info finfo;
107	int shift = 0;
108
109	rd = read(fd_hidraw, &uref, sizeof(uref));
110	if (rd < 0) {
111	logprintf(LOG_ERR, "error reading '%s'", hw.device);
112	logperror(LOG_ERR, NULL);
113	zotac_deinit();
114	error_state = 1;
115	return -1;
116	}
117
118	if (uref.field_index == HID_FIELD_INDEX_NONE) {
119	/*
120	* we get this when the new report has been send from
121	* device at this point we have the uref structure
122	* prefilled with correct report type and id
123	*
124	*/
125
126	switch (uref.report_id) {
127	case 1: /* USB standard keyboard usage page */
128	{
129	/* This page reports cursor keys */
130	LOGPRINTF(3, "Keyboard (standard)\n");
131
132	/* check for special codes */
133	uref.field_index = 0;
134	uref.usage_index = 1;
135	/* fetch the usage code for given indexes */
136	ioctl(fd_hidraw, HIDIOCGUCODE, &uref, sizeof(uref));
137	/* fetch the value from report */
138	ioctl(fd_hidraw, HIDIOCGUSAGE, &uref, sizeof(uref));
139
140	if (uref.value)
141	shift = 1;
142
143	/* populate required field number */
144	uref.field_index = 1;
145	uref.usage_index = 0;
146	/* fetch the usage code for given indexes */
147	ioctl(fd_hidraw, HIDIOCGUCODE, &uref, sizeof(uref));
148	/* fetch the value from report */
149	ioctl(fd_hidraw, HIDIOCGUSAGE, &uref, sizeof(uref));
150	/* now we have the key */
151
152	LOGPRINTF(3, "usage: %x value: %x shift: %d\n",uref.usage_code, uref.value, shift);
153
154	/* now we have the key */
155	if (uref.value) {
156	probe_code = (uref.usage_code \| uref.value);
157	if (shift)
158	probe_code \|= 0x10000000;
159	LOGPRINTF(3, "Main code 1: %x\n", probe_code);
160	return 1;
161	}
162	else {
163	LOGPRINTF(3, "rel button\n");
164	probe_code = release_code;
165	return 2;
166	}
167	}
168	break;
169
170	case 2:
171	case 3: /* USB generic desktop usage page */
172	case 4:
173	{
174	/* This page reports power key
175	* (via SystemControl SLEEP)
176	*/
177	LOGPRINTF(3, "Generic desktop (standard)\n");
178
179
180	/* traverse report descriptor */
181	rinfo.report_type = HID_REPORT_TYPE_INPUT;
182	rinfo.report_id = HID_REPORT_ID_FIRST;
183	rd = ioctl(fd_hidraw, HIDIOCGREPORTINFO, &rinfo);
184
185	unsigned int i,j;
186	while (rd >= 0) {
187	for (i = 0; i < rinfo.num_fields; i++) {
188	finfo.report_type = rinfo.report_type;
189	finfo.report_id = rinfo.report_id;
190	finfo.field_index = i;
191	ioctl(fd_hidraw, HIDIOCGFIELDINFO, &finfo);
192	for (j = 0; j < finfo.maxusage; j++) {
193	uref.field_index = i;
194	uref.usage_index = j;
195	ioctl(fd_hidraw, HIDIOCGUCODE, &uref);
196	ioctl(fd_hidraw, HIDIOCGUSAGE, &uref);
197
198	if (uref.value != 0) {
199	LOGPRINTF(3, "field: %d, idx: %d, usage: %x value: %x\n",i, j, uref.usage_code, uref.value);
200	probe_code = uref.usage_code;
201	return 1;
202	}
203	}
204	}
205	rinfo.report_id \|= HID_REPORT_ID_NEXT;
206	rd = ioctl(fd_hidraw, HIDIOCGREPORTINFO, &rinfo);
207	}
208	return 2;
209	}
210	break;
211	default:
212	/* Unknown/unsupported report id.
213	* Should not happen because remaining reports
214	* from report descriptor seem to be unused by remote.
215	*/
216	logprintf(LOG_ERR, "Unexpected report id %d", uref.report_id);
217	break;
218	}
219	}
220	else {
221	/* This page reports power key
222	* (via SystemControl SLEEP)
223	*/
224	LOGPRINTF(3, "Same Event ...\n");
225
226	/* traverse report descriptor */
227	rinfo.report_type = HID_REPORT_TYPE_INPUT;
228	rinfo.report_id = HID_REPORT_ID_FIRST;
229	rd = ioctl(fd_hidraw, HIDIOCGREPORTINFO, &rinfo);
230
231	unsigned int i,j;
232	while (rd >= 0) {
233	for (i = 0; i < rinfo.num_fields; i++) {
234	finfo.report_type = rinfo.report_type;
235	finfo.report_id = rinfo.report_id;
236	finfo.field_index = i;
237	ioctl(fd_hidraw, HIDIOCGFIELDINFO, &finfo);
238	for (j = 0; j < finfo.maxusage; j++) {
239	uref.field_index = i;
240	uref.usage_index = j;
241	ioctl(fd_hidraw, HIDIOCGUCODE, &uref);
242	ioctl(fd_hidraw, HIDIOCGUSAGE, &uref);
243
244	if (uref.value != 0) {
245	LOGPRINTF(3, "usage: %x value: %x\n",uref.usage_code, uref.value);
246	//probe_code = uref.usage_code;
247	return 0;
248	}
249	}
250	}
251	rinfo.report_id \|= HID_REPORT_ID_NEXT;
252	rd = ioctl(fd_hidraw, HIDIOCGREPORTINFO, &rinfo);
253	}
254	return 2;
255	}
256	return 0;
257	}
258
259	static int zotac_init()
260	{
261	logprintf(LOG_INFO, "zotac initializing '%s'", hw.device);
262	if ((fd_hidraw = open(hw.device, O_RDONLY)) < 0) {
263	logprintf(LOG_ERR, "unable to open '%s'", hw.device);
264	return 0;
265	}
266	int flags = HIDDEV_FLAG_UREF \| HIDDEV_FLAG_REPORT;
267	if (ioctl(fd_hidraw, HIDIOCSFLAG, &flags)) {
268	return 0;
269	}
270	hw.fd = fd_hidraw;
271
272	/* Create pipe so that events sent by the repeat thread will
273	trigger main thread */
274	if (pipe(fd_pipe) != 0) {
275	logperror(LOG_ERR, "couldn't open pipe");
276	close(fd_hidraw);
277	return 0;
278	}
279	hw.fd = fd_pipe[0];
280	/* Create thread to simulate repetitions */
281	if (pthread_create(&repeat_thread, NULL, zotac_repeat, NULL)) {
282	logprintf(LOG_ERR, "Could not create \"repeat thread\"");
283	return 0;
284	}
285	return 1;
286	}
287
288	static int zotac_deinit()
289	{
290	pthread_cancel(repeat_thread);
291	if (fd_hidraw != -1) {
292	// Close device if it is open
293	logprintf(LOG_INFO, "closing '%s'", hw.device);
294	close(fd_hidraw);
295	fd_hidraw = -1;
296	}
297	// Close pipe input
298	if (fd_pipe[1] >= 0) {
299	close(fd_pipe[1]);
300	fd_pipe[1] = -1;
301	}
302	// Close pipe output
303	if (fd_pipe[0] >= 0) {
304	close(fd_pipe[0]);
305	fd_pipe[0] = -1;
306	}
307	hw.fd = -1;
308	return 1;
309	}
310
311	/**
312	* Runtime that reads device, forwards codes to main thread
313	* and simulates repetitions.
314	*/
315	static void *zotac_repeat()
316	{
317	int repeat_count = 0;
318	unsigned current_code;
319	int ret;
320	int sel;
321	fd_set files;
322	struct timeval delay;
323	int pressed = 0;
324	int fd = fd_pipe[1];
325
326	while (1) {
327	// Initialize set to monitor device's events
328	FD_ZERO(&files);
329	FD_SET(fd_hidraw, &files);
330	if (pressed) {
331	sel = select(FD_SETSIZE, &files, NULL, NULL, &delay);
332	} else {
333	sel = select(FD_SETSIZE, &files, NULL, NULL, NULL);
334	}
335
336	switch (sel) {
337	case 1:
338	// Data ready in device's file
339	ret = zotac_getcode();
340
341	if (ret < 0) {
342	// Error
343	logprintf(LOG_ERR, "(%s) Could not read %s", __FUNCTION__, hw.device);
344	goto exit_loop;
345	}
346	if (ret == 1) {
347	// Key code : forward it to main thread
348	pressed = 1;
349	repeat_count = 0;
350	delay.tv_sec = 0;
351	delay.tv_usec = repeat_time1_us;
352	current_code = probe_code;
353	} else if (ret == 2) {
354	// Release code : stop repetitions
355	pressed = 0;
356	current_code = release_code;
357	} else if (ret == 0) {
358	continue;
359	}
360	break;
361	case 0:
362	repeat_count++;
363	if (repeat_count >= max_repeat_count) {
364	// Too many repetitions, something must have gone wrong
365	logprintf(LOG_ERR,"(%s) too many repetitions", __FUNCTION__);
366	goto exit_loop;
367	}
368	// Timeout : send current_code again to main
369	// thread to simulate repetition
370	delay.tv_sec = 0;
371	delay.tv_usec = repeat_time2_us;
372	break;
373	default:
374	// Error
375	logprintf(LOG_ERR, "(%s) select() failed", __FUNCTION__);
376	goto exit_loop;
377	}
378	// Send code to main thread through pipe
379	write(fd, &current_code, sizeof(current_code));
380	}
381	exit_loop:
382
383	// Wake up main thread with special key code
384	current_code = remove_code;
385	write(fd, &current_code, sizeof(current_code));
386	return NULL;
387	}
388
389	/*
390	* Aureal Technology ATWF@83 cheap remote
391	* specific code.
392	*/
393
394	static char zotac_rec(struct ir_remote remotes)
395	{
396	unsigned ev;
397	int rd;
398	last = end;
399	gettimeofday(&start, NULL);
400	rd = read(hw.fd, &ev, sizeof(ev));
401
402	if (rd == -1) {
403	// Error
404	logprintf(LOG_ERR, "(%s) could not read pipe", __FUNCTION__);
405	zotac_deinit();
406	return 0;
407	}
408
409	if (ev == release_code) {
410	// Release code
411	main_code = 0;
412	return 0;
413	} else if (ev == remove_code) {
414	// Device has been removed
415	zotac_deinit();
416	return 0;
417	}
418
419	LOGPRINTF(1, "zotac : %x", ev);
420	// Record the code and check for repetition
421	if (main_code == ev) {
422	repeat_state = RPT_YES;
423	} else {
424	main_code = ev;
425	repeat_state = RPT_NO;
426	}
427	gettimeofday(&end, NULL);
428	return decode_all(remotes);
429	}

Line 0 Link Here

(-)base/remotes/zotac/lircd.conf.zotac (+77 lines)
		1
		2	# Please make this file available to others
		3	# by sending it to <lirc@bartelmus.de>
		4	#
		5	# this config file was automatically generated
		6	# using lirc-0.9.1-git(zotac) on Mon Apr 2 14:10:29 2012
		7	#
		8	# contributed by
		9	#
		10	# brand: zotac.conf
		11	# model no. of remote control:
		12	# devices being controlled by this remote:
		13	#
		14
		15	begin remote
		16
		17	name zotac.conf
		18	bits 32
		19	eps 30
		20	aeps 100
		21
		22	one 0 0
		23	zero 0 0
		24	gap 100123
		25	min_repeat 9
		26	# suppress_repeat 9
		27	# uncomment to suppress unwanted repeats
		28	# toggle_bit_mask 0x7004F
		29
		30	begin codes
		31	KEY_SLEEP 0x00010082
		32	KEY_WAKEUP 0x00010083
		33	KEY_RECORD 0x000C00B2
		34	KEY_PAUSE 0x000C00B1
		35	KEY_STOP 0x000C00B7
		36	KEY_REWIND 0x000C00B4
		37	KEY_PLAY 0x000C00B0
		38	KEY_FORWARD 0x000C00B3
		39	KEY_LEFTSHIFT 0x000C00B6
		40	KEY_RIGHTSHIFT 0x000C00B5
		41	KEY_BACK 0x000C0224
		42	KEY_INFO 0x000C0209
		43	KEY_MENU 0xFFBC000D
		44	KEY_UP 0x00070052
		45	KEY_LEFT 0x00070050
		46	KEY_RIGHT 0x0007004F
		47	KEY_DOWN 0x00070051
		48	KEY_OK 0x00070028
		49	KEY_VOLUMEUP 0x000C00E9
		50	KEY_VOLUMEDOWN 0x000C00EA
		51	KEY_MUTE 0x000C00E2
		52	KEY_CHANNELUP 0x000C009C
		53	KEY_CHANNELDOWN 0x000C009D
		54	KEY_1 0x0007001E
		55	KEY_2 0x0007001F
		56	KEY_3 0x00070020
		57	KEY_4 0x00070021
		58	KEY_5 0x00070022
		59	KEY_6 0x00070023
		60	KEY_7 0x00070024
		61	KEY_8 0x00070025
		62	KEY_9 0x00070026
		63	KEY_0 0x00070027
		64	KEY_NUMERIC_STAR 0x10070025
65	KEY_NUMERIC_POUND 0x10070020
66	KEY_CLEAR 0x00070029
67	KEY_TEXT 0xFFBC005A
68	KEY_TITLE 0x000C008D
69	KEY_ENTER 0x00070028
70	KEY_RED 0xFFBC005B
71	KEY_GREEN 0xFFBC005C
72	KEY_YELLOW 0xFFBC005D
73	KEY_BLUE 0xFFBC005E
74	end codes
75
76	end remote
77