src/serial.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.com>
   5  * Copyright (C) 2010-2012 Uwe Hermann <uwe@hermann-uwe.de>
   6  * Copyright (C) 2012 Alexandru Gagniuc <mr.nuke.me@gmail.com>
   7  * Copyright (C) 2014 Uffe Jakobsen <uffe@uffe.org>
   8  *
   9  * This program is free software: you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation, either version 3 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include <config.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26 #include <glib.h>
  27 #include <glib/gstdio.h>
  28 #ifdef HAVE_LIBSERIALPORT
  29 #include <libserialport.h>
  30 #endif
  31 #include <libsigrok/libsigrok.h>
  32 #include "libsigrok-internal.h"
  33 #ifdef _WIN32
  34 #include <windows.h> /* for HANDLE */
  35 #endif
  36
  37 /** @cond PRIVATE */
  38 #define LOG_PREFIX "serial"
  39 /** @endcond */
  40
  41 /**
  42  * @file
  43  *
  44  * Serial port handling.
  45  */
  46
  47 /**
  48  * @defgroup grp_serial Serial port handling
  49  *
  50  * Serial port handling functions.
  51  *
  52  * @{
  53  */
  54
  55 #ifdef HAVE_SERIAL_COMM
  56
  57 /* See if a (assumed opened) serial port is of any supported type. */
  58 static int dev_is_supported(struct sr_serial_dev_inst *serial)
  59 {
  60         if (!serial)
  61                 return 0;
  62         if (!serial->lib_funcs)
  63                 return 0;
  64
  65         return 1;
  66 }
  67
  68 /**
  69  * Open the specified serial port.
  70  *
  71  * @param serial Previously initialized serial port structure.
  72  * @param[in] flags Flags to use when opening the serial port. Possible flags
  73  *                  include SERIAL_RDWR, SERIAL_RDONLY.
  74  *
  75  * If the serial structure contains a serialcomm string, it will be
  76  * passed to serial_set_paramstr() after the port is opened.
  77  *
  78  * @retval SR_OK Success.
  79  * @retval SR_ERR Failure.
  80  *
  81  * @private
  82  */
  83 SR_PRIV int serial_open(struct sr_serial_dev_inst *serial, int flags)
  84 {
  85         int ret;
  86
  87         if (!serial) {
  88                 sr_dbg("Invalid serial port.");
  89                 return SR_ERR;
  90         }
  91
  92         sr_spew("Opening serial port '%s' (flags %d).", serial->port, flags);
  93
  94         /* Default to the libserialport transport layer. */
  95         serial->lib_funcs = ser_lib_funcs_libsp;
  96         if (!serial->lib_funcs)
  97                 return SR_ERR_NA;
  98
  99         /*
 100          * Run the transport's open routine. Setup the bitrate and the
 101          * UART frame format.
 102          */
 103         if (!serial->lib_funcs->open)
 104                 return SR_ERR_NA;
 105         ret = serial->lib_funcs->open(serial, flags);
 106         if (ret != SR_OK)
 107                 return ret;
 108
 109         if (serial->serialcomm)
 110                 return serial_set_paramstr(serial, serial->serialcomm);
 111         else
 112                 return SR_OK;
 113 }
 114
 115 /**
 116  * Close the specified serial port.
 117  *
 118  * @param serial Previously initialized serial port structure.
 119  *
 120  * @retval SR_OK Success.
 121  * @retval SR_ERR Failure.
 122  *
 123  * @private
 124  */
 125 SR_PRIV int serial_close(struct sr_serial_dev_inst *serial)
 126 {
 127         if (!serial) {
 128                 sr_dbg("Invalid serial port.");
 129                 return SR_ERR;
 130         }
 131
 132         sr_spew("Closing serial port %s.", serial->port);
 133
 134         if (!serial->lib_funcs || !serial->lib_funcs->close)
 135                 return SR_ERR_NA;
 136
 137         return serial->lib_funcs->close(serial);
 138 }
 139
 140 /**
 141  * Flush serial port buffers. Empty buffers, discard pending RX and TX data.
 142  *
 143  * @param serial Previously initialized serial port structure.
 144  *
 145  * @retval SR_OK Success.
 146  * @retval SR_ERR Failure.
 147  *
 148  * @private
 149  */
 150 SR_PRIV int serial_flush(struct sr_serial_dev_inst *serial)
 151 {
 152         if (!serial) {
 153                 sr_dbg("Invalid serial port.");
 154                 return SR_ERR;
 155         }
 156
 157         sr_spew("Flushing serial port %s.", serial->port);
 158
 159         if (!serial->lib_funcs || !serial->lib_funcs->flush)
 160                 return SR_ERR_NA;
 161
 162         return serial->lib_funcs->flush(serial);
 163 }
 164
 165 /**
 166  * Drain serial port buffers. Wait for pending TX data to be sent.
 167  *
 168  * @param serial Previously initialized serial port structure.
 169  *
 170  * @retval SR_OK Success.
 171  * @retval SR_ERR Failure.
 172  *
 173  * @private
 174  */
 175 SR_PRIV int serial_drain(struct sr_serial_dev_inst *serial)
 176 {
 177         if (!serial) {
 178                 sr_dbg("Invalid serial port.");
 179                 return SR_ERR;
 180         }
 181
 182         sr_spew("Draining serial port %s.", serial->port);
 183
 184         if (!serial->lib_funcs || !serial->lib_funcs->drain)
 185                 return SR_ERR_NA;
 186
 187         return serial->lib_funcs->drain(serial);
 188 }
 189
 190 /**
 191  * Check for available receive data.
 192  *
 193  * @param[in] serial Previously opened serial port instance.
 194  *
 195  * @returns The number of (known) available RX data bytes.
 196  *
 197  * Returns 0 if no receive data is available, or if the amount of
 198  * available receive data cannot get determined.
 199  */
 200 SR_PRIV size_t serial_has_receive_data(struct sr_serial_dev_inst *serial)
 201 {
 202         size_t lib_count;
 203
 204         if (!serial)
 205                 return 0;
 206
 207         lib_count = 0;
 208         if (serial->lib_funcs && serial->lib_funcs->get_rx_avail)
 209                 lib_count = serial->lib_funcs->get_rx_avail(serial);
 210
 211         return lib_count;
 212 }
 213
 214 static int _serial_write(struct sr_serial_dev_inst *serial,
 215         const void *buf, size_t count,
 216         int nonblocking, unsigned int timeout_ms)
 217 {
 218         ssize_t ret;
 219
 220         if (!serial) {
 221                 sr_dbg("Invalid serial port.");
 222                 return SR_ERR;
 223         }
 224
 225         if (!serial->lib_funcs || !serial->lib_funcs->write)
 226                 return SR_ERR_NA;
 227         ret = serial->lib_funcs->write(serial, buf, count,
 228                 nonblocking, timeout_ms);
 229         sr_spew("Wrote %zd/%zu bytes.", ret, count);
 230
 231         return ret;
 232 }
 233
 234 /**
 235  * Write a number of bytes to the specified serial port, blocking until finished.
 236  *
 237  * @param serial Previously initialized serial port structure.
 238  * @param[in] buf Buffer containing the bytes to write.
 239  * @param[in] count Number of bytes to write.
 240  * @param[in] timeout_ms Timeout in ms, or 0 for no timeout.
 241  *
 242  * @retval SR_ERR_ARG Invalid argument.
 243  * @retval SR_ERR Other error.
 244  * @retval other The number of bytes written. If this is less than the number
 245  * specified in the call, the timeout was reached.
 246  *
 247  * @private
 248  */
 249 SR_PRIV int serial_write_blocking(struct sr_serial_dev_inst *serial,
 250         const void *buf, size_t count, unsigned int timeout_ms)
 251 {
 252         return _serial_write(serial, buf, count, 0, timeout_ms);
 253 }
 254
 255 /**
 256  * Write a number of bytes to the specified serial port, return immediately.
 257  *
 258  * @param serial Previously initialized serial port structure.
 259  * @param[in] buf Buffer containing the bytes to write.
 260  * @param[in] count Number of bytes to write.
 261  *
 262  * @retval SR_ERR_ARG Invalid argument.
 263  * @retval SR_ERR Other error.
 264  * @retval other The number of bytes written.
 265  *
 266  * @private
 267  */
 268 SR_PRIV int serial_write_nonblocking(struct sr_serial_dev_inst *serial,
 269         const void *buf, size_t count)
 270 {
 271         return _serial_write(serial, buf, count, 1, 0);
 272 }
 273
 274 static int _serial_read(struct sr_serial_dev_inst *serial,
 275         void *buf, size_t count, int nonblocking, unsigned int timeout_ms)
 276 {
 277         ssize_t ret;
 278
 279         if (!serial) {
 280                 sr_dbg("Invalid serial port.");
 281                 return SR_ERR;
 282         }
 283
 284         if (!serial->lib_funcs || !serial->lib_funcs->read)
 285                 return SR_ERR_NA;
 286         ret = serial->lib_funcs->read(serial, buf, count,
 287                 nonblocking, timeout_ms);
 288         if (ret > 0)
 289                 sr_spew("Read %zd/%zu bytes.", ret, count);
 290
 291         return ret;
 292 }
 293
 294 /**
 295  * Read a number of bytes from the specified serial port, block until finished.
 296  *
 297  * @param serial Previously initialized serial port structure.
 298  * @param buf Buffer where to store the bytes that are read.
 299  * @param[in] count The number of bytes to read.
 300  * @param[in] timeout_ms Timeout in ms, or 0 for no timeout.
 301  *
 302  * @retval SR_ERR_ARG Invalid argument.
 303  * @retval SR_ERR Other error.
 304  * @retval other The number of bytes read. If this is less than the number
 305  * requested, the timeout was reached.
 306  *
 307  * @private
 308  */
 309 SR_PRIV int serial_read_blocking(struct sr_serial_dev_inst *serial,
 310         void *buf, size_t count, unsigned int timeout_ms)
 311 {
 312         return _serial_read(serial, buf, count, 0, timeout_ms);
 313 }
 314
 315 /**
 316  * Try to read up to @a count bytes from the specified serial port, return
 317  * immediately with what's available.
 318  *
 319  * @param serial Previously initialized serial port structure.
 320  * @param buf Buffer where to store the bytes that are read.
 321  * @param[in] count The number of bytes to read.
 322  *
 323  * @retval SR_ERR_ARG Invalid argument.
 324  * @retval SR_ERR Other error.
 325  * @retval other The number of bytes read.
 326  *
 327  * @private
 328  */
 329 SR_PRIV int serial_read_nonblocking(struct sr_serial_dev_inst *serial,
 330         void *buf, size_t count)
 331 {
 332         return _serial_read(serial, buf, count, 1, 0);
 333 }
 334
 335 /**
 336  * Set serial parameters for the specified serial port.
 337  *
 338  * @param serial Previously initialized serial port structure.
 339  * @param[in] baudrate The baudrate to set.
 340  * @param[in] bits The number of data bits to use (5, 6, 7 or 8).
 341  * @param[in] parity The parity setting to use (0 = none, 1 = even, 2 = odd).
 342  * @param[in] stopbits The number of stop bits to use (1 or 2).
 343  * @param[in] flowcontrol The flow control settings to use (0 = none,
 344  *                        1 = RTS/CTS, 2 = XON/XOFF).
 345  * @param[in] rts Status of RTS line (0 or 1; required by some interfaces).
 346  * @param[in] dtr Status of DTR line (0 or 1; required by some interfaces).
 347  *
 348  * @retval SR_OK Success.
 349  * @retval SR_ERR Failure.
 350  *
 351  * @private
 352  */
 353 SR_PRIV int serial_set_params(struct sr_serial_dev_inst *serial,
 354         int baudrate, int bits, int parity, int stopbits,
 355         int flowcontrol, int rts, int dtr)
 356 {
 357         int ret;
 358
 359         if (!serial) {
 360                 sr_dbg("Invalid serial port.");
 361                 return SR_ERR;
 362         }
 363
 364         sr_spew("Setting serial parameters on port %s.", serial->port);
 365
 366         if (!serial->lib_funcs || !serial->lib_funcs->set_params)
 367                 return SR_ERR_NA;
 368         ret = serial->lib_funcs->set_params(serial,
 369                 baudrate, bits, parity, stopbits,
 370                 flowcontrol, rts, dtr);
 371         if (ret == SR_OK) {
 372                 serial->comm_params.bit_rate = baudrate;
 373                 serial->comm_params.data_bits = bits;
 374                 serial->comm_params.parity_bits = parity ? 1 : 0;
 375                 serial->comm_params.stop_bits = stopbits;
 376                 sr_dbg("DBG: %s() rate %d, %d%s%d", __func__,
 377                                 baudrate, bits,
 378                                 (parity == 0) ? "n" : "x",
 379                                 stopbits);
 380         }
 381
 382         return ret;
 383 }
 384
 385 /**
 386  * Set serial parameters for the specified serial port from parameter string.
 387  *
 388  * @param serial Previously initialized serial port structure.
 389  * @param[in] paramstr A serial communication parameters string of the form
 390  * "<baudrate>/<bits><parity><stopbits>{/<option>}".\n
 391  * Examples: "9600/8n1", "600/7o2/dtr=1/rts=0" or "460800/8n1/flow=2".\n
 392  * \<baudrate\>=integer Baud rate.\n
 393  * \<bits\>=5|6|7|8 Number of data bits.\n
 394  * \<parity\>=n|e|o None, even, odd.\n
 395  * \<stopbits\>=1|2 One or two stop bits.\n
 396  * Options:\n
 397  * dtr=0|1 Set DTR off resp. on.\n
 398  * flow=0|1|2 Flow control. 0 for none, 1 for RTS/CTS, 2 for XON/XOFF.\n
 399  * rts=0|1 Set RTS off resp. on.\n
 400  * Please note that values and combinations of these parameters must be
 401  * supported by the concrete serial interface hardware and the drivers for it.
 402  *
 403  * @retval SR_OK Success.
 404  * @retval SR_ERR Failure.
 405  *
 406  * @private
 407  */
 408 SR_PRIV int serial_set_paramstr(struct sr_serial_dev_inst *serial,
 409         const char *paramstr)
 410 {
 411 /** @cond PRIVATE */
 412 #define SERIAL_COMM_SPEC "^(\\d+)/([5678])([neo])([12])(.*)$"
 413 /** @endcond */
 414
 415         GRegex *reg;
 416         GMatchInfo *match;
 417         int speed, databits, parity, stopbits, flow, rts, dtr, i;
 418         char *mstr, **opts, **kv;
 419
 420         speed = databits = parity = stopbits = flow = 0;
 421         rts = dtr = -1;
 422         sr_spew("Parsing parameters from \"%s\".", paramstr);
 423         reg = g_regex_new(SERIAL_COMM_SPEC, 0, 0, NULL);
 424         if (g_regex_match(reg, paramstr, 0, &match)) {
 425                 if ((mstr = g_match_info_fetch(match, 1)))
 426                         speed = strtoul(mstr, NULL, 10);
 427                 g_free(mstr);
 428                 if ((mstr = g_match_info_fetch(match, 2)))
 429                         databits = strtoul(mstr, NULL, 10);
 430                 g_free(mstr);
 431                 if ((mstr = g_match_info_fetch(match, 3))) {
 432                         switch (mstr[0]) {
 433                         case 'n':
 434                                 parity = SP_PARITY_NONE;
 435                                 break;
 436                         case 'e':
 437                                 parity = SP_PARITY_EVEN;
 438                                 break;
 439                         case 'o':
 440                                 parity = SP_PARITY_ODD;
 441                                 break;
 442                         }
 443                 }
 444                 g_free(mstr);
 445                 if ((mstr = g_match_info_fetch(match, 4)))
 446                         stopbits = strtoul(mstr, NULL, 10);
 447                 g_free(mstr);
 448                 if ((mstr = g_match_info_fetch(match, 5)) && mstr[0] != '\0') {
 449                         if (mstr[0] != '/') {
 450                                 sr_dbg("missing separator before extra options");
 451                                 speed = 0;
 452                         } else {
 453                                 /* A set of "key=value" options separated by / */
 454                                 opts = g_strsplit(mstr + 1, "/", 0);
 455                                 for (i = 0; opts[i]; i++) {
 456                                         kv = g_strsplit(opts[i], "=", 2);
 457                                         if (!strncmp(kv[0], "rts", 3)) {
 458                                                 if (kv[1][0] == '1')
 459                                                         rts = 1;
 460                                                 else if (kv[1][0] == '0')
 461                                                         rts = 0;
 462                                                 else {
 463                                                         sr_dbg("invalid value for rts: %c", kv[1][0]);
 464                                                         speed = 0;
 465                                                 }
 466                                         } else if (!strncmp(kv[0], "dtr", 3)) {
 467                                                 if (kv[1][0] == '1')
 468                                                         dtr = 1;
 469                                                 else if (kv[1][0] == '0')
 470                                                         dtr = 0;
 471                                                 else {
 472                                                         sr_dbg("invalid value for dtr: %c", kv[1][0]);
 473                                                         speed = 0;
 474                                                 }
 475                                         } else if (!strncmp(kv[0], "flow", 4)) {
 476                                                 if (kv[1][0] == '0')
 477                                                         flow = 0;
 478                                                 else if (kv[1][0] == '1')
 479                                                         flow = 1;
 480                                                 else if (kv[1][0] == '2')
 481                                                         flow = 2;
 482                                                 else {
 483                                                         sr_dbg("invalid value for flow: %c", kv[1][0]);
 484                                                         speed = 0;
 485                                                 }
 486                                         }
 487                                         g_strfreev(kv);
 488                                 }
 489                                 g_strfreev(opts);
 490                         }
 491                 }
 492                 g_free(mstr);
 493         }
 494         g_match_info_unref(match);
 495         g_regex_unref(reg);
 496
 497         if (speed) {
 498                 return serial_set_params(serial, speed, databits, parity,
 499                                          stopbits, flow, rts, dtr);
 500         } else {
 501                 sr_dbg("Could not infer speed from parameter string.");
 502                 return SR_ERR_ARG;
 503         }
 504 }
 505
 506 /**
 507  * Read a line from the specified serial port.
 508  *
 509  * @param[in] serial Previously initialized serial port structure.
 510  * @param[out] buf Buffer where to store the bytes that are read.
 511  * @param[in] buflen Size of the buffer.
 512  * @param[in] timeout_ms How long to wait for a line to come in.
 513  *
 514  * Reading stops when CR or LF is found, which is stripped from the buffer.
 515  *
 516  * @retval SR_OK Success.
 517  * @retval SR_ERR Failure.
 518  *
 519  * @private
 520  */
 521 SR_PRIV int serial_readline(struct sr_serial_dev_inst *serial,
 522         char **buf, int *buflen, gint64 timeout_ms)
 523 {
 524         gint64 start, remaining;
 525         int maxlen, len;
 526
 527         if (!serial) {
 528                 sr_dbg("Invalid serial port.");
 529                 return SR_ERR;
 530         }
 531
 532         if (!dev_is_supported(serial)) {
 533                 sr_dbg("Cannot use unopened serial port %s.", serial->port);
 534                 return -1;
 535         }
 536
 537         start = g_get_monotonic_time();
 538         remaining = timeout_ms;
 539
 540         maxlen = *buflen;
 541         *buflen = len = 0;
 542         while (1) {
 543                 len = maxlen - *buflen - 1;
 544                 if (len < 1)
 545                         break;
 546                 len = serial_read_blocking(serial, *buf + *buflen, 1, remaining);
 547                 if (len > 0) {
 548                         *buflen += len;
 549                         *(*buf + *buflen) = '\0';
 550                         if (*buflen > 0 && (*(*buf + *buflen - 1) == '\r'
 551                                         || *(*buf + *buflen - 1) == '\n')) {
 552                                 /* Strip CR/LF and terminate. */
 553                                 *(*buf + --*buflen) = '\0';
 554                                 break;
 555                         }
 556                 }
 557                 /* Reduce timeout by time elapsed. */
 558                 remaining = timeout_ms - ((g_get_monotonic_time() - start) / 1000);
 559                 if (remaining <= 0)
 560                         /* Timeout */
 561                         break;
 562                 if (len < 1)
 563                         g_usleep(2000);
 564         }
 565         if (*buflen)
 566                 sr_dbg("Received %d: '%s'.", *buflen, *buf);
 567
 568         return SR_OK;
 569 }
 570
 571 /**
 572  * Try to find a valid packet in a serial data stream.
 573  *
 574  * @param serial Previously initialized serial port structure.
 575  * @param buf Buffer containing the bytes to write.
 576  * @param buflen Size of the buffer.
 577  * @param[in] packet_size Size, in bytes, of a valid packet.
 578  * @param is_valid Callback that assesses whether the packet is valid or not.
 579  * @param[in] timeout_ms The timeout after which, if no packet is detected, to
 580  *                       abort scanning.
 581  * @param[in] baudrate The baudrate of the serial port. This parameter is not
 582  *                     critical, but it helps fine tune the serial port polling
 583  *                     delay.
 584  *
 585  * @retval SR_OK Valid packet was found within the given timeout.
 586  * @retval SR_ERR Failure.
 587  *
 588  * @private
 589  */
 590 SR_PRIV int serial_stream_detect(struct sr_serial_dev_inst *serial,
 591         uint8_t *buf, size_t *buflen,
 592         size_t packet_size,
 593         packet_valid_callback is_valid,
 594         uint64_t timeout_ms, int baudrate)
 595 {
 596         uint64_t start, time, byte_delay_us;
 597         size_t ibuf, i, maxlen;
 598         ssize_t len;
 599
 600         maxlen = *buflen;
 601
 602         sr_dbg("Detecting packets on %s (timeout = %" PRIu64
 603                "ms, baudrate = %d).", serial->port, timeout_ms, baudrate);
 604
 605         if (maxlen < (packet_size / 2) ) {
 606                 sr_err("Buffer size must be at least twice the packet size.");
 607                 return SR_ERR;
 608         }
 609
 610         /* Assume 8n1 transmission. That is 10 bits for every byte. */
 611         byte_delay_us = 10 * ((1000 * 1000) / baudrate);
 612         start = g_get_monotonic_time();
 613
 614         i = ibuf = len = 0;
 615         while (ibuf < maxlen) {
 616                 len = serial_read_nonblocking(serial, &buf[ibuf], 1);
 617                 if (len > 0) {
 618                         ibuf += len;
 619                 } else if (len == 0) {
 620                         /* No logging, already done in serial_read(). */
 621                 } else {
 622                         /* Error reading byte, but continuing anyway. */
 623                 }
 624
 625                 time = g_get_monotonic_time() - start;
 626                 time /= 1000;
 627
 628                 if ((ibuf - i) >= packet_size) {
 629                         GString *text;
 630                         /* We have at least a packet's worth of data. */
 631                         text = sr_hexdump_new(&buf[i], packet_size);
 632                         sr_spew("Trying packet: %s", text->str);
 633                         sr_hexdump_free(text);
 634                         if (is_valid(&buf[i])) {
 635                                 sr_spew("Found valid %zu-byte packet after "
 636                                         "%" PRIu64 "ms.", (ibuf - i), time);
 637                                 *buflen = ibuf;
 638                                 return SR_OK;
 639                         } else {
 640                                 sr_spew("Got %zu bytes, but not a valid "
 641                                         "packet.", (ibuf - i));
 642                         }
 643                         /* Not a valid packet. Continue searching. */
 644                         i++;
 645                 }
 646                 if (time >= timeout_ms) {
 647                         /* Timeout */
 648                         sr_dbg("Detection timed out after %" PRIu64 "ms.", time);
 649                         break;
 650                 }
 651                 if (len < 1)
 652                         g_usleep(byte_delay_us);
 653         }
 654
 655         *buflen = ibuf;
 656
 657         sr_err("Didn't find a valid packet (read %zu bytes).", *buflen);
 658
 659         return SR_ERR;
 660 }
 661
 662 /**
 663  * Extract the serial device and options from the options linked list.
 664  *
 665  * @param options List of options passed from the command line.
 666  * @param serial_device Pointer where to store the extracted serial device.
 667  * @param serial_options Pointer where to store the optional extracted serial
 668  * options.
 669  *
 670  * @return SR_OK if a serial_device is found, SR_ERR if no device is found. The
 671  * returned string should not be freed by the caller.
 672  *
 673  * @private
 674  */
 675 SR_PRIV int sr_serial_extract_options(GSList *options,
 676         const char **serial_device, const char **serial_options)
 677 {
 678         GSList *l;
 679         struct sr_config *src;
 680
 681         *serial_device = NULL;
 682
 683         for (l = options; l; l = l->next) {
 684                 src = l->data;
 685                 switch (src->key) {
 686                 case SR_CONF_CONN:
 687                         *serial_device = g_variant_get_string(src->data, NULL);
 688                         sr_dbg("Parsed serial device: %s.", *serial_device);
 689                         break;
 690                 case SR_CONF_SERIALCOMM:
 691                         *serial_options = g_variant_get_string(src->data, NULL);
 692                         sr_dbg("Parsed serial options: %s.", *serial_options);
 693                         break;
 694                 }
 695         }
 696
 697         if (!*serial_device) {
 698                 sr_dbg("No serial device specified.");
 699                 return SR_ERR;
 700         }
 701
 702         return SR_OK;
 703 }
 704
 705 /** @private */
 706 SR_PRIV int serial_source_add(struct sr_session *session,
 707         struct sr_serial_dev_inst *serial, int events, int timeout,
 708         sr_receive_data_callback cb, void *cb_data)
 709 {
 710         if ((events & (G_IO_IN | G_IO_ERR)) && (events & G_IO_OUT)) {
 711                 sr_err("Cannot poll input/error and output simultaneously.");
 712                 return SR_ERR_ARG;
 713         }
 714
 715         if (!dev_is_supported(serial)) {
 716                 sr_err("Invalid serial port.");
 717                 return SR_ERR_ARG;
 718         }
 719
 720         if (!serial->lib_funcs || !serial->lib_funcs->setup_source_add)
 721                 return SR_ERR_NA;
 722
 723         return serial->lib_funcs->setup_source_add(session, serial,
 724                 events, timeout, cb, cb_data);
 725 }
 726
 727 /** @private */
 728 SR_PRIV int serial_source_remove(struct sr_session *session,
 729         struct sr_serial_dev_inst *serial)
 730 {
 731         if (!dev_is_supported(serial)) {
 732                 sr_err("Invalid serial port.");
 733                 return SR_ERR_ARG;
 734         }
 735
 736         if (!serial->lib_funcs || !serial->lib_funcs->setup_source_remove)
 737                 return SR_ERR_NA;
 738
 739         return serial->lib_funcs->setup_source_remove(session, serial);
 740 }
 741
 742 /**
 743  * Create/allocate a new sr_serial_port structure.
 744  *
 745  * @param name The OS dependent name of the serial port. Must not be NULL.
 746  * @param description An end user friendly description for the serial port.
 747  *                    Can be NULL (in that case the empty string is used
 748  *                    as description).
 749  *
 750  * @return The newly allocated sr_serial_port struct.
 751  */
 752 static struct sr_serial_port *sr_serial_new(const char *name,
 753         const char *description)
 754 {
 755         struct sr_serial_port *serial;
 756
 757         if (!name)
 758                 return NULL;
 759
 760         serial = g_malloc0(sizeof(*serial));
 761         serial->name = g_strdup(name);
 762         serial->description = g_strdup(description ? description : "");
 763
 764         return serial;
 765 }
 766
 767 /**
 768  * Free a previously allocated sr_serial_port structure.
 769  *
 770  * @param serial The sr_serial_port struct to free. Must not be NULL.
 771  */
 772 SR_API void sr_serial_free(struct sr_serial_port *serial)
 773 {
 774         if (!serial)
 775                 return;
 776         g_free(serial->name);
 777         g_free(serial->description);
 778         g_free(serial);
 779 }
 780
 781 static GSList *append_port_list(GSList *devs, const char *name, const char *desc)
 782 {
 783         return g_slist_append(devs, sr_serial_new(name, desc));
 784 }
 785
 786 /**
 787  * List available serial devices.
 788  *
 789  * @return A GSList of strings containing the path of the serial devices or
 790  *         NULL if no serial device is found. The returned list must be freed
 791  *         by the caller.
 792  */
 793 SR_API GSList *sr_serial_list(const struct sr_dev_driver *driver)
 794 {
 795         GSList *tty_devs;
 796         GSList *(*list_func)(GSList *list, sr_ser_list_append_t append);
 797
 798         /* Currently unused, but will be used by some drivers later on. */
 799         (void)driver;
 800
 801         tty_devs = NULL;
 802         if (ser_lib_funcs_libsp && ser_lib_funcs_libsp->list) {
 803                 list_func = ser_lib_funcs_libsp->list;
 804                 tty_devs = list_func(tty_devs, append_port_list);
 805         }
 806
 807         return tty_devs;
 808 }
 809
 810 static GSList *append_port_find(GSList *devs, const char *name)
 811 {
 812         if (!name || !*name)
 813                 return devs;
 814
 815         return g_slist_append(devs, g_strdup(name));
 816 }
 817
 818 /**
 819  * Find USB serial devices via the USB vendor ID and product ID.
 820  *
 821  * @param[in] vendor_id Vendor ID of the USB device.
 822  * @param[in] product_id Product ID of the USB device.
 823  *
 824  * @return A GSList of strings containing the path of the serial device or
 825  *         NULL if no serial device is found. The returned list must be freed
 826  *         by the caller.
 827  *
 828  * @private
 829  */
 830 SR_PRIV GSList *sr_serial_find_usb(uint16_t vendor_id, uint16_t product_id)
 831 {
 832         GSList *tty_devs;
 833         GSList *(*find_func)(GSList *list, sr_ser_find_append_t append,
 834                         uint16_t vid, uint16_t pid);
 835
 836         tty_devs = NULL;
 837         if (ser_lib_funcs_libsp && ser_lib_funcs_libsp->find_usb) {
 838                 find_func = ser_lib_funcs_libsp->find_usb;
 839                 tty_devs = find_func(tty_devs, append_port_find,
 840                         vendor_id, product_id);
 841         }
 842
 843         return tty_devs;
 844 }
 845
 846 /** @private */
 847 SR_PRIV int serial_timeout(struct sr_serial_dev_inst *port, int num_bytes)
 848 {
 849         int bits, baud;
 850         int ret;
 851         int timeout_ms;
 852
 853         /* Get the bitrate and frame length. */
 854         bits = baud = 0;
 855         if (port->lib_funcs && port->lib_funcs->get_frame_format) {
 856                 ret = port->lib_funcs->get_frame_format(port, &baud, &bits);
 857                 if (ret != SR_OK)
 858                         bits = baud = 0;
 859         } else {
 860                 baud = port->comm_params.bit_rate;
 861                 bits = 1 + port->comm_params.data_bits +
 862                         port->comm_params.parity_bits +
 863                         port->comm_params.stop_bits;
 864         }
 865
 866         /* Derive the timeout. Default to 1s. */
 867         timeout_ms = 1000;
 868         if (bits && baud) {
 869                 /* Throw in 10ms for misc OS overhead. */
 870                 timeout_ms = 10;
 871                 timeout_ms += ((1000.0 / baud) * bits) * num_bytes;
 872         }
 873
 874         return timeout_ms;
 875 }
 876
 877 #else
 878
 879 /* TODO Put fallback.c content here? */
 880
 881 #endif
 882
 883 /** @} */