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.1  2001/11/25 21:58:58  short
  15   :pserver:cvs@pserver.samba.org:/cvsroot - gnokii - Sun Nov 25 22:56 CET 2001
  16
  17   Revision 1.11  2001/09/14 12:15:28  pkot
  18   Cleanups from 0.3.3 (part1)
  19
  20   Revision 1.10  2001/08/20 23:27:37  pkot
  21   Add hardware shakehand to the link layer (Manfred Jonsson)
  22
  23   Revision 1.9  2001/06/28 00:28:45  pkot
  24   Small docs updates (Pawel Kot)
  25
  26   Revision 1.8  2001/02/21 19:56:55  chris
  27   More fiddling with the directory layout
  28
  29   Revision 1.7  2001/02/09 18:12:53  chris
  30   Marcel's tekram support
  31
  32   Revision 1.6  2001/02/03 23:56:12  chris
  33   Start of work on irda support (now we just need fbus-irda.c!)
  34   Proper unicode support in 7110 code (from pkot)
  35
  36
  37 */
  38
  39 #ifndef WIN32
  40
  41 #include "devices/unixserial.h"
  42 #include "devices/unixirda.h"
  43 #include "devices/tekram.h"
  44 #include "device.h"
  45
  46 /*
  47  * Structure to store the filedescriptor we use.
  48  *
  49  */
  50
  51 int device_portfd = -1;
  52
  53 /* The device type to use */
  54
  55 GSM_ConnectionType devicetype;
  56
  57 int device_getfd(void) {
  58
  59   return device_portfd;
  60 }
  61
  62 int device_open(__const char *__file, int __with_odd_parity, int __with_async, int __with_hw_handshake, GSM_ConnectionType device_type)
  63 {
  64   devicetype = device_type;
  65
  66   switch (devicetype) {
  67   case GCT_Serial:
  68   case GCT_Infrared:
  69     device_portfd = serial_opendevice(__file, __with_odd_parity, __with_async, __with_hw_handshake);
  70     break;
  71   case GCT_Tekram:
  72     device_portfd = tekram_open(__file);
  73     break;
  74   case GCT_Irda:
  75     device_portfd = irda_open();
  76     break;
  77   default:
  78     break;
  79   }
  80   return (device_portfd >= 0);
  81 }
  82
  83 void device_close(void)
  84 {
  85   switch (devicetype) {
  86   case GCT_Serial:
  87   case GCT_Infrared:
  88     serial_close(device_portfd);
  89     break;
  90   case GCT_Tekram:
  91     tekram_close(device_portfd);
  92     break;
  93   case GCT_Irda:
  94     irda_close(device_portfd);
  95     break;
  96   default:
  97     break;
  98   }
  99 }
 100
 101 void device_reset(void)
 102 {
 103 }
 104
 105 void device_setdtrrts(int __dtr, int __rts)
 106 {
 107   switch (devicetype) {
 108   case GCT_Serial:
 109   case GCT_Infrared:
 110     serial_setdtrrts(device_portfd, __dtr, __rts);
 111     break;
 112   case GCT_Tekram:
 113     break;
 114   case GCT_Irda:
 115     break;
 116   default:
 117     break;
 118   }
 119 }
 120
 121 void device_changespeed(int __speed)
 122 {
 123   switch (devicetype) {
 124   case GCT_Serial:
 125   case GCT_Infrared:
 126     serial_changespeed(device_portfd, __speed);
 127     break;
 128   case GCT_Tekram:
 129     tekram_changespeed(device_portfd, __speed);
 130     break;
 131   case GCT_Irda:
 132     break;
 133   default:
 134     break;
 135   }
 136 }
 137
 138 size_t device_read(__ptr_t __buf, size_t __nbytes)
 139 {
 140   switch (devicetype) {
 141   case GCT_Serial:
 142   case GCT_Infrared:
 143     return (serial_read(device_portfd, __buf, __nbytes));
 144     break;
 145   case GCT_Tekram:
 146     return (tekram_read(device_portfd, __buf, __nbytes));
 147     break;
 148   case GCT_Irda:
 149     return irda_read(device_portfd, __buf, __nbytes);
 150     break;
 151   default:
 152     break;
 153   }
 154   return 0;
 155 }
 156
 157 size_t device_write(__const __ptr_t __buf, size_t __n)
 158 {
 159   switch (devicetype) {
 160   case GCT_Serial:
 161   case GCT_Infrared:
 162     return (serial_write(device_portfd, __buf, __n));
 163     break;
 164   case GCT_Tekram:
 165     return (tekram_write(device_portfd, __buf, __n));
 166     break;
 167   case GCT_Irda:
 168     return irda_write(device_portfd, __buf, __n);
 169     break;
 170   default:
 171     break;
 172   }
 173   return 0;
 174 }
 175
 176 int device_select(struct timeval *timeout)
 177 {
 178   switch (devicetype) {
 179   case GCT_Serial:
 180   case GCT_Infrared:
 181     return serial_select(device_portfd, timeout);
 182     break;
 183   case GCT_Tekram:
 184     return tekram_select(device_portfd, timeout);
 185     break;
 186   case GCT_Irda:
 187     return irda_select(device_portfd, timeout);
 188     break;
 189   default:
 190     break;
 191   }
 192   return -1;
 193 }
 194
 195 #endif /* WIN32 */
 196