common/device.c

   1 /*
   2
   3   $Id$
   4
   5   G N O K I I
   6
   7   A Linux/Unix toolset and driver for Nokia mobile phones.
   8
   9   Copyright (C) 1999, 2000 Hugh Blemings & Pavel Janík ml.
  10
  11   Released under the terms of the GNU GPL, see file COPYING for more details.
  12
  13   $Log$
  14   Revision 1.1.1.2  2002/04/03 01:44:15  short
  15   Implemented connection type "tcp" (GCT_TCP), use <hostname>:<port> as "port"
  16
  17   Revision 1.1.1.1  2001/11/25 21:58:58  short
  18   :pserver:cvs@pserver.samba.org:/cvsroot - gnokii - Sun Nov 25 22:56 CET 2001
  19
  20   Revision 1.11  2001/09/14 12:15:28  pkot
  21   Cleanups from 0.3.3 (part1)
  22
  23   Revision 1.10  2001/08/20 23:27:37  pkot
  24   Add hardware shakehand to the link layer (Manfred Jonsson)
  25
  26   Revision 1.9  2001/06/28 00:28:45  pkot
  27   Small docs updates (Pawel Kot)
  28
  29   Revision 1.8  2001/02/21 19:56:55  chris
  30   More fiddling with the directory layout
  31
  32   Revision 1.7  2001/02/09 18:12:53  chris
  33   Marcel's tekram support
  34
  35   Revision 1.6  2001/02/03 23:56:12  chris
  36   Start of work on irda support (now we just need fbus-irda.c!)
  37   Proper unicode support in 7110 code (from pkot)
  38
  39
  40 */
  41
  42 #ifndef WIN32
  43
  44 #include "devices/unixserial.h"
  45 #include "devices/unixirda.h"
  46 #include "devices/tekram.h"
  47 #include "devices/tcp.h"
  48 #include "device.h"
  49
  50 /*
  51  * Structure to store the filedescriptor we use.
  52  *
  53  */
  54
  55 int device_portfd = -1;
  56
  57 /* The device type to use */
  58
  59 GSM_ConnectionType devicetype;
  60
  61 int device_getfd(void) {
  62
  63   return device_portfd;
  64 }
  65
  66 int device_open(__const char *__file, int __with_odd_parity, int __with_async, int __with_hw_handshake, GSM_ConnectionType device_type)
  67 {
  68   devicetype = device_type;
  69
  70   switch (devicetype) {
  71   case GCT_Serial:
  72   case GCT_Infrared:
  73     device_portfd = serial_opendevice(__file, __with_odd_parity, __with_async, __with_hw_handshake);
  74     break;
  75   case GCT_Tekram:
  76     device_portfd = tekram_open(__file);
  77     break;
  78   case GCT_Irda:
  79     device_portfd = irda_open();
  80     break;
  81   case GCT_TCP:
  82     device_portfd = tcp_opendevice(__file, __with_async);
  83     break;
  84   default:
  85     break;
  86   }
  87   return (device_portfd >= 0);
  88 }
  89
  90 void device_close(void)
  91 {
  92   switch (devicetype) {
  93   case GCT_Serial:
  94   case GCT_Infrared:
  95     serial_close(device_portfd);
  96     break;
  97   case GCT_Tekram:
  98     tekram_close(device_portfd);
  99     break;
 100   case GCT_Irda:
 101     irda_close(device_portfd);
 102     break;
 103   case GCT_TCP:
 104     tcp_close(device_portfd);
 105     break;
 106   default:
 107     break;
 108   }
 109 }
 110
 111 void device_reset(void)
 112 {
 113 }
 114
 115 void device_setdtrrts(int __dtr, int __rts)
 116 {
 117   switch (devicetype) {
 118   case GCT_Serial:
 119   case GCT_Infrared:
 120     serial_setdtrrts(device_portfd, __dtr, __rts);
 121     break;
 122   case GCT_Tekram:
 123     break;
 124   case GCT_Irda:
 125     break;
 126   case GCT_TCP:
 127     break;
 128   default:
 129     break;
 130   }
 131 }
 132
 133 void device_changespeed(int __speed)
 134 {
 135   switch (devicetype) {
 136   case GCT_Serial:
 137   case GCT_Infrared:
 138     serial_changespeed(device_portfd, __speed);
 139     break;
 140   case GCT_Tekram:
 141     tekram_changespeed(device_portfd, __speed);
 142     break;
 143   case GCT_Irda:
 144     break;
 145   case GCT_TCP:
 146     break;
 147   default:
 148     break;
 149   }
 150 }
 151
 152 size_t device_read(__ptr_t __buf, size_t __nbytes)
 153 {
 154   switch (devicetype) {
 155   case GCT_Serial:
 156   case GCT_Infrared:
 157     return (serial_read(device_portfd, __buf, __nbytes));
 158     break;
 159   case GCT_Tekram:
 160     return (tekram_read(device_portfd, __buf, __nbytes));
 161     break;
 162   case GCT_Irda:
 163     return irda_read(device_portfd, __buf, __nbytes);
 164     break;
 165   case GCT_TCP:
 166     return tcp_read(device_portfd, __buf, __nbytes);
 167     break;
 168   default:
 169     break;
 170   }
 171   return 0;
 172 }
 173
 174 size_t device_write(__const __ptr_t __buf, size_t __n)
 175 {
 176   switch (devicetype) {
 177   case GCT_Serial:
 178   case GCT_Infrared:
 179     return (serial_write(device_portfd, __buf, __n));
 180     break;
 181   case GCT_Tekram:
 182     return (tekram_write(device_portfd, __buf, __n));
 183     break;
 184   case GCT_Irda:
 185     return irda_write(device_portfd, __buf, __n);
 186     break;
 187   case GCT_TCP:
 188     return tcp_write(device_portfd, __buf, __n);
 189     break;
 190   default:
 191     break;
 192   }
 193   return 0;
 194 }
 195
 196 int device_select(struct timeval *timeout)
 197 {
 198   switch (devicetype) {
 199   case GCT_Serial:
 200   case GCT_Infrared:
 201     return serial_select(device_portfd, timeout);
 202     break;
 203   case GCT_Tekram:
 204     return tekram_select(device_portfd, timeout);
 205     break;
 206   case GCT_Irda:
 207     return irda_select(device_portfd, timeout);
 208     break;
 209   case GCT_TCP:
 210     return tcp_select(device_portfd, timeout);
 211     break;
 212   default:
 213     break;
 214   }
 215   return -1;
 216 }
 217
 218 #endif /* WIN32 */
 219