lirc-0.8.4a/daemons/hw_usbx.c

   1 /*****************************************************************************
   2  ** hw_usbx.c ****************************************************************
   3  *****************************************************************************
   4  * Routines for the ADSTech USBX-707 USB IR Blaster
   5  *
   6  * Only receiving is implemented.
   7  *
   8  * It uses a baudrate of 300kps on a USB serial device which, currently, is
   9  * only supported by Linux.
  10  * If someone knows how to set such a baudrate under other OS's, please add
  11  * that functionality to daemons/serial.c to make this driver work for those
  12  * OS's.
  13  *
  14  * Information on how to send with this device is greatly appreciated...
  15  *
  16  * Copyright (C) 2007 Jelle Foks <jelle@foks.8m.com>
  17  *
  18  *  This program is free software; you can redistribute it and/or modify
  19  *  it under the terms of the GNU General Public License as published by
  20  *  the Free Software Foundation; either version 2 of the License, or
  21  *  (at your option) any later version.
  22  *
  23  *  This program is distributed in the hope that it will be useful,
  24  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  *  GNU Library General Public License for more details.
  27  *
  28  *  You should have received a copy of the GNU General Public License
  29  *  along with this program; if not, write to the Free Software
  30  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  31  *
  32  */
  33 #ifdef HAVE_CONFIG_H
  34 #include <config.h>
  35 #endif
  36
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <fcntl.h>
  40 #include <unistd.h>
  41 #include <limits.h>
  42 #include <signal.h>
  43 #include <sys/stat.h>
  44 #include <sys/types.h>
  45 #include <sys/ioctl.h>
  46 #include <errno.h>
  47 #include <termios.h>
  48
  49 #include "hardware.h"
  50 #include "receive.h"
  51 #include "serial.h"
  52 #include "ir_remote.h"
  53 #include "lircd.h"
  54 #include "hw_usbx.h"
  55
  56 static unsigned char b[6];
  57 static ir_code code;
  58
  59 #define REPEAT_FLAG ((ir_code) 0x1)
  60 #define CODE_LENGTH 48
  61
  62 struct hardware hw_usbx = {
  63         LIRC_IRTTY,                      /* Default device */
  64         -1,                              /* fd */
  65         LIRC_CAN_REC_LIRCCODE,           /* Features */
  66         0,                               /* send_mode */
  67         LIRC_MODE_LIRCCODE,              /* rec_mode */
  68         CODE_LENGTH,                     /* code_length */
  69         usbx_init,                       /* init_func */
  70         NULL,                            /* config_func */
  71         usbx_deinit,                     /* deinit_func */
  72         NULL,                            /* send_func */
  73         usbx_rec,                        /* rec_func */
  74         usbx_decode,                     /* decode_func */
  75         NULL,                            /* ioctl_func */
  76         NULL,                            /* readdata */
  77         "usbx"
  78 };
  79
  80 int usbx_decode (struct ir_remote *remote, ir_code *prep, ir_code *codep,
  81                  ir_code *postp, int *repeat_flagp,
  82                  lirc_t *min_remaining_gapp, lirc_t *max_remaining_gapp)
  83 {
  84         if( remote->flags&CONST_LENGTH ||
  85             !map_code(remote, prep, codep, postp,
  86                       0, 0, CODE_LENGTH, code&(~REPEAT_FLAG), 0, 0))
  87         {
  88                 return 0;
  89         }
  90         /* the lsb in the code is the repeat flag */
  91         *repeat_flagp = code&REPEAT_FLAG ? 1:0;
  92         *min_remaining_gapp=min_gap(remote);
  93         *max_remaining_gapp=max_gap(remote);
  94
  95         LOGPRINTF(1, "repeat_flagp: %d",*repeat_flagp);
  96         LOGPRINTF(1, "remote->gap range:      %lu %lu\n",
  97                   (unsigned long) min_gap(remote),
  98                   (unsigned long) max_gap(remote));
  99         LOGPRINTF(1,"rem: %lu %lu",
 100                   (unsigned long) remote->min_remaining_gap,
 101                   (unsigned long) remote->max_remaining_gap);
 102         return 1;
 103 }
 104
 105 int usbx_init(void)
 106 {
 107         if(!tty_create_lock(hw.device))
 108         {
 109                 logprintf(LOG_ERR,"could not create lock files for '%s'",
 110                           hw.device);
 111                 return 0;
 112         }
 113         if ( (hw.fd = open (hw.device, O_RDWR | O_NONBLOCK | O_NOCTTY)) < 0)
 114         {
 115                 tty_delete_lock ();
 116                 logprintf (LOG_ERR, "Could not open the '%s' device",
 117                            hw.device);
 118                 return 0;
 119         }
 120         LOGPRINTF(1, "device '%s' opened", hw.device);
 121
 122         if(!tty_reset(hw.fd) ||
 123            !tty_setbaud(hw.fd, 300000) ||
 124            !tty_setrtscts(hw.fd, 1))
 125         {
 126                 logprintf(LOG_ERR,"could not configure the serial port for "
 127                           "'%s'", hw.device);
 128                 usbx_deinit();
 129                 return 0;
 130         }
 131
 132         return 1;
 133 }
 134
 135 int usbx_deinit (void)
 136 {
 137         close(hw.fd);
 138         hw.fd = -1;
 139         tty_delete_lock();
 140         return 1;
 141 }
 142
 143 char *usbx_rec (struct ir_remote *remotes)
 144 {
 145         char        *m;
 146         int         i, x;
 147
 148         x = 0;
 149         for (i = 0 ; i < 6; i++)
 150         {
 151                 if (i > 0)
 152                 {
 153                         if (!waitfordata(20000))
 154                         {
 155                                 LOGPRINTF(LOG_ERR,"timeout reading byte %d",i);
 156                                 break;
 157                         }
 158                 }
 159                 if (read(hw.fd, &b[i], 1) != 1)
 160                 {
 161                         LOGPRINTF(LOG_ERR, "reading of byte %d failed.", i);
 162                         usbx_deinit();
 163                         return NULL;
 164                 }
 165                 LOGPRINTF(1, "byte %d: %02x", i, b[i]);
 166                 x++;
 167         }
 168         code = 0;
 169         for ( i = 0 ; i < x ; i++ )
 170         {
 171                 code =  code << 8;
 172                 code |= ((ir_code) b[i]);
 173         }
 174
 175         LOGPRINTF(1," -> %0llx",(unsigned long long) code);
 176
 177         m = decode_all(remotes);
 178         return m;
 179 }