hardware/common/serial.c

   1 /*
   2  * This file is part of the sigrok 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  *
   8  * This program is free software: you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation, either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <string.h>
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25 #include <fcntl.h>
  26 #include <unistd.h>
  27 #ifdef _WIN32
  28 #include <windows.h>
  29 #else
  30 #include <glob.h>
  31 #include <termios.h>
  32 #include <sys/ioctl.h>
  33 #endif
  34 #include <stdlib.h>
  35 #include <errno.h>
  36 #include <glib.h>
  37 #include "libsigrok.h"
  38 #include "libsigrok-internal.h"
  39
  40 /* Message logging helpers with driver-specific prefix string. */
  41 #define DRIVER_LOG_DOMAIN "serial: "
  42 #define sr_log(l, s, args...) sr_log(l, DRIVER_LOG_DOMAIN s, ## args)
  43 #define sr_spew(s, args...) sr_spew(DRIVER_LOG_DOMAIN s, ## args)
  44 #define sr_dbg(s, args...) sr_dbg(DRIVER_LOG_DOMAIN s, ## args)
  45 #define sr_info(s, args...) sr_info(DRIVER_LOG_DOMAIN s, ## args)
  46 #define sr_warn(s, args...) sr_warn(DRIVER_LOG_DOMAIN s, ## args)
  47 #define sr_err(s, args...) sr_err(DRIVER_LOG_DOMAIN s, ## args)
  48
  49 // FIXME: Must be moved, or rather passed as function argument.
  50 #ifdef _WIN32
  51 static HANDLE hdl;
  52 #endif
  53
  54 /**
  55  * Open the specified serial port.
  56  *
  57  * @param serial Previously initialized serial port structure.
  58  * @param flags Flags to use when opening the serial port. Possible flags
  59  *              include SERIAL_RDWR, SERIAL_RDONLY, SERIAL_NONBLOCK.
  60  *
  61  * If the serial structure contains a serialcomm string, it will be
  62  * passed to serial_set_paramstr() after the port is opened.
  63  *
  64  * @return SR_OK on success, SR_ERR on failure.
  65  */
  66 SR_PRIV int serial_open(struct sr_serial_dev_inst *serial, int flags)
  67 {
  68         int flags_local = 0;
  69 #ifdef _WIN32
  70         DWORD desired_access = 0, flags_and_attributes = 0;
  71 #endif
  72
  73         if (!serial) {
  74                 sr_dbg("Invalid serial port.");
  75                 return SR_ERR;
  76         }
  77
  78         sr_spew("Opening serial port '%s' (flags %d).", serial->port, flags);
  79
  80 #ifdef _WIN32
  81         /* Map 'flags' to the OS-specific settings. */
  82         desired_access |= GENERIC_READ;
  83         flags_and_attributes = FILE_ATTRIBUTE_NORMAL;
  84         if (flags & SERIAL_RDWR)
  85                 desired_access |= GENERIC_WRITE;
  86         if (flags & SERIAL_NONBLOCK)
  87                 flags_and_attributes |= FILE_FLAG_OVERLAPPED;
  88
  89         hdl = CreateFile(serial->port, desired_access, 0, 0,
  90                          OPEN_EXISTING, flags_and_attributes, 0);
  91         if (hdl == INVALID_HANDLE_VALUE) {
  92                 sr_err("Error opening serial port '%s'.", serial->port);
  93                 return SR_ERR;
  94         }
  95 #else
  96         /* Map 'flags' to the OS-specific settings. */
  97         if (flags & SERIAL_RDWR)
  98                 flags_local |= O_RDWR;
  99         if (flags & SERIAL_RDONLY)
 100                 flags_local |= O_RDONLY;
 101         if (flags & SERIAL_NONBLOCK)
 102                 flags_local |= O_NONBLOCK;
 103
 104         if ((serial->fd = open(serial->port, flags_local)) < 0) {
 105                 sr_err("Error opening serial port '%s': %s.", serial->port,
 106                        strerror(errno));
 107                 return SR_ERR;
 108         }
 109
 110         sr_spew("Opened serial port '%s' (fd %d).", serial->port, serial->fd);
 111 #endif
 112
 113         if (serial->serialcomm)
 114                 return serial_set_paramstr(serial, serial->serialcomm);
 115         else
 116                 return SR_OK;
 117 }
 118
 119 /**
 120  * Close the specified serial port.
 121  *
 122  * @param serial Previously initialized serial port structure.
 123  *
 124  * @return SR_OK on success, SR_ERR on failure.
 125  */
 126 SR_PRIV int serial_close(struct sr_serial_dev_inst *serial)
 127 {
 128         int ret;
 129
 130         if (!serial) {
 131                 sr_dbg("Invalid serial port.");
 132                 return SR_ERR;
 133         }
 134
 135         if (serial->fd == -1) {
 136                 sr_dbg("Cannot close unopened serial port %s (fd %d).",
 137                                 serial->port, serial->fd);
 138                 return SR_ERR;
 139         }
 140
 141         sr_spew("Closing serial port %s (fd %d).", serial->port, serial->fd);
 142         ret = SR_OK;
 143
 144 #ifdef _WIN32
 145         /* Returns non-zero upon success, 0 upon failure. */
 146         if (CloseHandle(hdl) == 0)
 147                 ret = SR_ERR;
 148 #else
 149         /* Returns 0 upon success, -1 upon failure. */
 150         if (close(serial->fd) < 0) {
 151                 sr_err("Error closing serial port: %s (fd %d).", strerror(errno),
 152                                 serial->fd);
 153                 ret = SR_ERR;
 154         }
 155 #endif
 156
 157         serial->fd = -1;
 158
 159         return ret;
 160 }
 161
 162 /**
 163  * Flush serial port buffers.
 164  *
 165  * @param serial Previously initialized serial port structure.
 166  *
 167  * @return SR_OK on success, SR_ERR on failure.
 168  */
 169 SR_PRIV int serial_flush(struct sr_serial_dev_inst *serial)
 170 {
 171         int ret;
 172
 173         if (!serial) {
 174                 sr_dbg("Invalid serial port.");
 175                 return SR_ERR;
 176         }
 177
 178         if (serial->fd == -1) {
 179                 sr_dbg("Cannot flush unopened serial port %s (fd %d).",
 180                                 serial->port, serial->fd);
 181                 return SR_ERR;
 182         }
 183
 184         sr_spew("Flushing serial port %s (fd %d).", serial->port, serial->fd);
 185         ret = SR_OK;
 186
 187 #ifdef _WIN32
 188         /* Returns non-zero upon success, 0 upon failure. */
 189         if (PurgeComm(hdl, PURGE_RXCLEAR | PURGE_TXCLEAR) == 0) {
 190                 sr_err("Error flushing serial port: %s.", strerror(errno));
 191                 ret = SR_ERR;
 192         }
 193 #else
 194         /* Returns 0 upon success, -1 upon failure. */
 195         if (tcflush(serial->fd, TCIOFLUSH) < 0) {
 196                 sr_err("Error flushing serial port: %s.", strerror(errno));
 197                 ret = SR_ERR;
 198         }
 199
 200         return ret;
 201 #endif
 202 }
 203
 204 /**
 205  * Write a number of bytes to the specified serial port.
 206  *
 207  * @param serial Previously initialized serial port structure.
 208  * @param buf Buffer containing the bytes to write.
 209  * @param count Number of bytes to write.
 210  *
 211  * @return The number of bytes written, or -1 upon failure.
 212  */
 213 SR_PRIV int serial_write(struct sr_serial_dev_inst *serial,
 214                 const void *buf, size_t count)
 215 {
 216         ssize_t ret;
 217
 218         if (!serial) {
 219                 sr_dbg("Invalid serial port.");
 220                 return -1;
 221         }
 222
 223         if (serial->fd == -1) {
 224                 sr_dbg("Cannot use unopened serial port %s (fd %d).",
 225                                 serial->port, serial->fd);
 226                 return -1;
 227         }
 228
 229 #ifdef _WIN32
 230         DWORD tmp = 0;
 231
 232         /* FIXME */
 233         /* Returns non-zero upon success, 0 upon failure. */
 234         WriteFile(hdl, buf, count, &tmp, NULL);
 235 #else
 236         /* Returns the number of bytes written, or -1 upon failure. */
 237         ret = write(serial->fd, buf, count);
 238         if (ret < 0)
 239                 sr_err("Write error: %s.", strerror(errno));
 240         else
 241                 sr_spew("Wrote %d/%d bytes (fd %d).", ret, count, serial->fd);
 242 #endif
 243
 244         return ret;
 245 }
 246
 247 /**
 248  * Read a number of bytes from the specified serial port.
 249  *
 250  * @param serial Previously initialized serial port structure.
 251  * @param buf Buffer where to store the bytes that are read.
 252  * @param count The number of bytes to read.
 253  *
 254  * @return The number of bytes read, or -1 upon failure.
 255  */
 256 SR_PRIV int serial_read(struct sr_serial_dev_inst *serial, void *buf,
 257                 size_t count)
 258 {
 259         ssize_t ret;
 260
 261         if (!serial) {
 262                 sr_dbg("Invalid serial port.");
 263                 return -1;
 264         }
 265
 266         if (serial->fd == -1) {
 267                 sr_dbg("Cannot use unopened serial port %s (fd %d).",
 268                                 serial->port, serial->fd);
 269                 return -1;
 270         }
 271
 272 #ifdef _WIN32
 273         DWORD tmp = 0;
 274
 275         /* FIXME */
 276         /* Returns non-zero upon success, 0 upon failure. */
 277         return ReadFile(hdl, buf, count, &tmp, NULL);
 278 #else
 279         /* Returns the number of bytes read, or -1 upon failure. */
 280         ret = read(serial->fd, buf, count);
 281 #endif
 282
 283         return ret;
 284 }
 285
 286 /**
 287  * Set serial parameters for the specified serial port.
 288  *
 289  * @param serial Previously initialized serial port structure.
 290  * @param baudrate The baudrate to set.
 291  * @param bits The number of data bits to use.
 292  * @param parity The parity setting to use (0 = none, 1 = even, 2 = odd).
 293  * @param stopbits The number of stop bits to use (1 or 2).
 294  * @param flowcontrol The flow control settings to use (0 = none, 1 = RTS/CTS,
 295  *                    2 = XON/XOFF).
 296  *
 297  * @return SR_OK upon success, SR_ERR upon failure.
 298  */
 299 SR_PRIV int serial_set_params(struct sr_serial_dev_inst *serial, int baudrate,
 300                               int bits, int parity, int stopbits,
 301                               int flowcontrol, int rts, int dtr)
 302 {
 303         if (!serial) {
 304                 sr_dbg("Invalid serial port.");
 305                 return SR_ERR;
 306         }
 307
 308         if (serial->fd == -1) {
 309                 sr_dbg("Cannot configure unopened serial port %s (fd %d).",
 310                        serial->port, serial->fd);
 311                 return SR_ERR;
 312         }
 313
 314         sr_spew("Setting serial parameters on port %s (fd %d).", serial->port,
 315                 serial->fd);
 316
 317 #ifdef _WIN32
 318         DCB dcb;
 319
 320         if (!GetCommState(hdl, &dcb)) {
 321                 sr_err("Failed to get comm state on port %s (fd %d): %d.",
 322                        serial->port, serial->fd, GetLastError());
 323                 return SR_ERR;
 324         }
 325
 326         switch (baudrate) {
 327         /*
 328          * The baudrates 50/75/134/150/200/1800/230400/460800 do not seem to
 329          * have documented CBR_* macros.
 330          */
 331         case 110:
 332                 dcb.BaudRate = CBR_110;
 333                 break;
 334         case 300:
 335                 dcb.BaudRate = CBR_300;
 336                 break;
 337         case 600:
 338                 dcb.BaudRate = CBR_600;
 339                 break;
 340         case 1200:
 341                 dcb.BaudRate = CBR_1200;
 342                 break;
 343         case 2400:
 344                 dcb.BaudRate = CBR_2400;
 345                 break;
 346         case 4800:
 347                 dcb.BaudRate = CBR_4800;
 348                 break;
 349         case 9600:
 350                 dcb.BaudRate = CBR_9600;
 351                 break;
 352         case 14400:
 353                 dcb.BaudRate = CBR_14400; /* Not available on Unix? */
 354                 break;
 355         case 19200:
 356                 dcb.BaudRate = CBR_19200;
 357                 break;
 358         case 38400:
 359                 dcb.BaudRate = CBR_38400;
 360                 break;
 361         case 57600:
 362                 dcb.BaudRate = CBR_57600;
 363                 break;
 364         case 115200:
 365                 dcb.BaudRate = CBR_115200;
 366                 break;
 367         case 128000:
 368                 dcb.BaudRate = CBR_128000; /* Not available on Unix? */
 369                 break;
 370         case 256000:
 371                 dcb.BaudRate = CBR_256000; /* Not available on Unix? */
 372                 break;
 373         default:
 374                 sr_err("Unsupported baudrate: %d.", baudrate);
 375                 return SR_ERR;
 376         }
 377         sr_spew("Configuring baudrate to %d (%d).", baudrate, dcb.BaudRate);
 378
 379         sr_spew("Configuring %d data bits.", bits);
 380         dcb.ByteSize = bits;
 381
 382         sr_spew("Configuring %d stop bits.", stopbits);
 383         switch (stopbits) {
 384         /* Note: There's also ONE5STOPBITS == 1.5 (unneeded so far). */
 385         case 1:
 386                 dcb.StopBits = ONESTOPBIT;
 387                 break;
 388         case 2:
 389                 dcb.StopBits = TWOSTOPBITS;
 390                 break;
 391         default:
 392                 sr_err("Unsupported stopbits number: %d.", stopbits);
 393                 return SR_ERR;
 394         }
 395
 396         switch (parity) {
 397         /* Note: There's also SPACEPARITY, MARKPARITY (unneeded so far). */
 398         case SERIAL_PARITY_NONE:
 399                 sr_spew("Configuring no parity.");
 400                 dcb.Parity = NOPARITY;
 401                 break;
 402         case SERIAL_PARITY_EVEN:
 403                 sr_spew("Configuring even parity.");
 404                 dcb.Parity = EVENPARITY;
 405                 break;
 406         case SERIAL_PARITY_ODD:
 407                 sr_spew("Configuring odd parity.");
 408                 dcb.Parity = ODDPARITY;
 409                 break;
 410         default:
 411                 sr_err("Unsupported parity setting: %d.", parity);
 412                 return SR_ERR;
 413         }
 414
 415         if (rts != -1) {
 416                 sr_spew("Setting RTS %s.", rts ? "high" : "low");
 417                 if (rts)
 418                         dcb.fRtsControl = RTS_CONTROL_ENABLE;
 419                 else
 420                         dcb.fRtsControl = RTS_CONTROL_DISABLE;
 421         }
 422
 423         if (dtr != -1) {
 424                 sr_spew("Setting DTR %s.", dtr ? "high" : "low");
 425                 if (dtr)
 426                         dcb.fDtrControl = DTR_CONTROL_ENABLE;
 427                 else
 428                         dcb.fDtrControl = DTR_CONTROL_DISABLE;
 429         }
 430
 431         if (!SetCommState(hdl, &dcb)) {
 432                 sr_err("Failed to set comm state on port %s (fd %d): %d.",
 433                        serial->port, serial->fd, GetLastError());
 434                 return SR_ERR;
 435         }
 436 #else
 437         struct termios term;
 438         speed_t baud;
 439         int ret, controlbits;
 440
 441         if (tcgetattr(serial->fd, &term) < 0) {
 442                 sr_err("tcgetattr() error on port %s (fd %d): %s.",
 443                                 serial->port, serial->fd, strerror(errno));
 444                 return SR_ERR;
 445         }
 446
 447         switch (baudrate) {
 448         case 50:
 449                 baud = B50;
 450                 break;
 451         case 75:
 452                 baud = B75;
 453                 break;
 454         case 110:
 455                 baud = B110;
 456                 break;
 457         case 134:
 458                 baud = B134;
 459                 break;
 460         case 150:
 461                 baud = B150;
 462                 break;
 463         case 200:
 464                 baud = B200;
 465                 break;
 466         case 300:
 467                 baud = B300;
 468                 break;
 469         case 600:
 470                 baud = B600;
 471                 break;
 472         case 1200:
 473                 baud = B1200;
 474                 break;
 475         case 1800:
 476                 baud = B1800;
 477                 break;
 478         case 2400:
 479                 baud = B2400;
 480                 break;
 481         case 4800:
 482                 baud = B4800;
 483                 break;
 484         case 9600:
 485                 baud = B9600;
 486                 break;
 487         case 19200:
 488                 baud = B19200;
 489                 break;
 490         case 38400:
 491                 baud = B38400;
 492                 break;
 493         case 57600:
 494                 baud = B57600;
 495                 break;
 496         case 115200:
 497                 baud = B115200;
 498                 break;
 499         case 230400:
 500                 baud = B230400;
 501                 break;
 502 #if !defined(__APPLE__) && !defined(__OpenBSD__)
 503         case 460800:
 504                 baud = B460800;
 505                 break;
 506 #endif
 507         default:
 508                 sr_err("Unsupported baudrate: %d.", baudrate);
 509                 return SR_ERR;
 510         }
 511
 512         sr_spew("Configuring output baudrate to %d (%d).", baudrate, baud);
 513         if (cfsetospeed(&term, baud) < 0) {
 514                 sr_err("cfsetospeed() error: %s.", strerror(errno));
 515                 return SR_ERR;
 516         }
 517
 518         sr_spew("Configuring input baudrate to %d (%d).", baudrate, baud);
 519         if (cfsetispeed(&term, baud) < 0) {
 520                 sr_err("cfsetispeed() error: %s.", strerror(errno));
 521                 return SR_ERR;
 522         }
 523
 524         sr_spew("Configuring %d data bits.", bits);
 525         term.c_cflag &= ~CSIZE;
 526         switch (bits) {
 527         case 8:
 528                 term.c_cflag |= CS8;
 529                 break;
 530         case 7:
 531                 term.c_cflag |= CS7;
 532                 break;
 533         default:
 534                 sr_err("Unsupported data bits number %d.", bits);
 535                 return SR_ERR;
 536         }
 537
 538         sr_spew("Configuring %d stop bits.", stopbits);
 539         term.c_cflag &= ~CSTOPB;
 540         switch (stopbits) {
 541         case 1:
 542                 term.c_cflag &= ~CSTOPB;
 543                 break;
 544         case 2:
 545                 term.c_cflag |= CSTOPB;
 546                 break;
 547         default:
 548                 sr_err("Unsupported stopbits number %d.", stopbits);
 549                 return SR_ERR;
 550         }
 551
 552         term.c_iflag &= ~(IXON | IXOFF);
 553         term.c_cflag &= ~CRTSCTS;
 554         switch (flowcontrol) {
 555         case 0:
 556                 /* No flow control. */
 557                 sr_spew("Configuring no flow control.");
 558                 break;
 559         case 1:
 560                 sr_spew("Configuring RTS/CTS flow control.");
 561                 term.c_cflag |= CRTSCTS;
 562                 break;
 563         case 2:
 564                 sr_spew("Configuring XON/XOFF flow control.");
 565                 term.c_iflag |= IXON | IXOFF;
 566                 break;
 567         default:
 568                 sr_err("Unsupported flow control setting %d.", flowcontrol);
 569                 return SR_ERR;
 570         }
 571
 572         term.c_iflag &= ~IGNPAR;
 573         term.c_cflag &= ~(PARODD | PARENB);
 574         switch (parity) {
 575         case SERIAL_PARITY_NONE:
 576                 sr_spew("Configuring no parity.");
 577                 term.c_iflag |= IGNPAR;
 578                 break;
 579         case SERIAL_PARITY_EVEN:
 580                 sr_spew("Configuring even parity.");
 581                 term.c_cflag |= PARENB;
 582                 break;
 583         case SERIAL_PARITY_ODD:
 584                 sr_spew("Configuring odd parity.");
 585                 term.c_cflag |= PARENB | PARODD;
 586                 break;
 587         default:
 588                 sr_err("Unsupported parity setting %d.", parity);
 589                 return SR_ERR;
 590         }
 591
 592         /* Do not translate carriage return to newline on input. */
 593         term.c_iflag &= ~(ICRNL);
 594
 595         /* Disable canonical mode, and don't echo input characters. */
 596         term.c_lflag &= ~(ICANON | ECHO);
 597
 598         /* Write the configured settings. */
 599         if (tcsetattr(serial->fd, TCSADRAIN, &term) < 0) {
 600                 sr_err("tcsetattr() error: %s.", strerror(errno));
 601                 return SR_ERR;
 602         }
 603
 604         if (rts != -1) {
 605                 sr_spew("Setting RTS %s.", rts ? "high" : "low");
 606                 controlbits = TIOCM_RTS;
 607                 if ((ret = ioctl(serial->fd, rts ? TIOCMBIS : TIOCMBIC,
 608                                 &controlbits)) < 0) {
 609                         sr_err("Error setting RTS: %s.", strerror(errno));
 610                         return SR_ERR;
 611                 }
 612         }
 613
 614         if (dtr != -1) {
 615                 sr_spew("Setting DTR %s.", dtr ? "high" : "low");
 616                 controlbits = TIOCM_DTR;
 617                 if ((ret = ioctl(serial->fd, dtr ? TIOCMBIS : TIOCMBIC,
 618                                 &controlbits)) < 0) {
 619                         sr_err("Error setting DTR: %s.", strerror(errno));
 620                         return SR_ERR;
 621                 }
 622         }
 623
 624 #endif
 625
 626         return SR_OK;
 627 }
 628
 629 /**
 630  * Set serial parameters for the specified serial port.
 631  *
 632  * @param serial Previously initialized serial port structure.
 633  * @param paramstr A serial communication parameters string, in the form
 634  * of <speed>/<data bits><parity><stopbits><flow>, for example "9600/8n1" or
 635  * "600/7o2" or "460800/8n1/flow=2" where flow is 0 for none, 1 for rts/cts and 2 for xon/xoff.
 636  *
 637  * @return SR_OK upon success, SR_ERR upon failure.
 638  */
 639 #define SERIAL_COMM_SPEC "^(\\d+)/([78])([neo])([12])(.*)$"
 640 SR_PRIV int serial_set_paramstr(struct sr_serial_dev_inst *serial,
 641                 const char *paramstr)
 642 {
 643         GRegex *reg;
 644         GMatchInfo *match;
 645         int speed, databits, parity, stopbits, flow, rts, dtr, i;
 646         char *mstr, **opts, **kv;
 647
 648         speed = databits = parity = stopbits = flow = 0;
 649         rts = dtr = -1;
 650         sr_spew("Parsing parameters from \"%s\".", paramstr);
 651         reg = g_regex_new(SERIAL_COMM_SPEC, 0, 0, NULL);
 652         if (g_regex_match(reg, paramstr, 0, &match)) {
 653                 if ((mstr = g_match_info_fetch(match, 1)))
 654                         speed = strtoul(mstr, NULL, 10);
 655                 g_free(mstr);
 656                 if ((mstr = g_match_info_fetch(match, 2)))
 657                         databits = strtoul(mstr, NULL, 10);
 658                 g_free(mstr);
 659                 if ((mstr = g_match_info_fetch(match, 3))) {
 660                         switch (mstr[0]) {
 661                         case 'n':
 662                                 parity = SERIAL_PARITY_NONE;
 663                                 break;
 664                         case 'e':
 665                                 parity = SERIAL_PARITY_EVEN;
 666                                 break;
 667                         case 'o':
 668                                 parity = SERIAL_PARITY_ODD;
 669                                 break;
 670                         }
 671                 }
 672                 g_free(mstr);
 673                 if ((mstr = g_match_info_fetch(match, 4)))
 674                         stopbits = strtoul(mstr, NULL, 10);
 675                 g_free(mstr);
 676                 if ((mstr = g_match_info_fetch(match, 5)) && mstr[0] != '\0') {
 677                         if (mstr[0] != '/') {
 678                                 sr_dbg("missing separator before extra options");
 679                                 speed = 0;
 680                         } else {
 681                                 /* A set of "key=value" options separated by / */
 682                                 opts = g_strsplit(mstr + 1, "/", 0);
 683                                 for (i = 0; opts[i]; i++) {
 684                                         kv = g_strsplit(opts[i], "=", 2);
 685                                         if (!strncmp(kv[0], "rts", 3)) {
 686                                                 if (kv[1][0] == '1')
 687                                                         rts = 1;
 688                                                 else if (kv[1][0] == '0')
 689                                                         rts = 0;
 690                                                 else {
 691                                                         sr_dbg("invalid value for rts: %c", kv[1][0]);
 692                                                         speed = 0;
 693                                                 }
 694                                         } else if (!strncmp(kv[0], "dtr", 3)) {
 695                                                 if (kv[1][0] == '1')
 696                                                         dtr = 1;
 697                                                 else if (kv[1][0] == '0')
 698                                                         dtr = 0;
 699                                                 else {
 700                                                         sr_dbg("invalid value for dtr: %c", kv[1][0]);
 701                                                         speed = 0;
 702                                                 }
 703                                         } else if (!strncmp(kv[0], "flow", 4)) {
 704                                                 if (kv[1][0] == '0')
 705                                                         flow = 0;
 706                                                 else if (kv[1][0] == '1')
 707                                                         flow = 1;
 708                                                 else if (kv[1][0] == '2')
 709                                                         flow = 2;
 710                                                 else {
 711                                                         sr_dbg("invalid value for flow: %c", kv[1][0]);
 712                                                         speed = 0;
 713                                                 }
 714                                         }
 715                                         g_strfreev(kv);
 716                                 }
 717                                 g_strfreev(opts);
 718                         }
 719                 }
 720                 g_free(mstr);
 721         }
 722         g_match_info_unref(match);
 723         g_regex_unref(reg);
 724
 725         if (speed) {
 726                 return serial_set_params(serial, speed, databits, parity,
 727                                          stopbits, flow, rts, dtr);
 728         } else {
 729                 sr_dbg("Could not infer speed from parameter string.");
 730                 return SR_ERR_ARG;
 731         }
 732 }
 733
 734 /**
 735  * Read a line from the specified serial port.
 736  *
 737  * @param serial Previously initialized serial port structure.
 738  * @param buf Buffer where to store the bytes that are read.
 739  * @param buflen Size of the buffer.
 740  * @param timeout_ms How long to wait for a line to come in.
 741  *
 742  * Reading stops when CR of LR is found, which is stripped from the buffer.
 743  *
 744  * @return SR_OK on success, SR_ERR on failure.
 745  */
 746 SR_PRIV int serial_readline(struct sr_serial_dev_inst *serial, char **buf,
 747                 int *buflen, gint64 timeout_ms)
 748 {
 749         gint64 start;
 750         int maxlen, len;
 751
 752         if (!serial || serial->fd == -1) {
 753                 sr_dbg("Invalid serial port.");
 754                 return SR_ERR;
 755         }
 756
 757         if (serial->fd == -1) {
 758                 sr_dbg("Cannot use unopened serial port %s (fd %d).",
 759                                 serial->port, serial->fd);
 760                 return -1;
 761         }
 762
 763         timeout_ms *= 1000;
 764         start = g_get_monotonic_time();
 765
 766         maxlen = *buflen;
 767         *buflen = len = 0;
 768         while(1) {
 769                 len = maxlen - *buflen - 1;
 770                 if (len < 1)
 771                         break;
 772                 len = serial_read(serial, *buf + *buflen, 1);
 773                 if (len > 0) {
 774                         *buflen += len;
 775                         *(*buf + *buflen) = '\0';
 776                         if (*buflen > 0 && (*(*buf + *buflen - 1) == '\r'
 777                                         || *(*buf + *buflen - 1) == '\n')) {
 778                                 /* Strip CR/LF and terminate. */
 779                                 *(*buf + --*buflen) = '\0';
 780                                 break;
 781                         }
 782                 }
 783                 if (g_get_monotonic_time() - start > timeout_ms)
 784                         /* Timeout */
 785                         break;
 786                 g_usleep(2000);
 787         }
 788         if (*buflen)
 789                 sr_dbg("Received %d: '%s'.", *buflen, *buf);
 790
 791         return SR_OK;
 792 }
 793
 794 /**
 795  * Try to find a valid packet in a serial data stream.
 796  *
 797  * @param serial Previously initialized serial port structure.
 798  * @param buf Buffer containing the bytes to write.
 799  * @param count Size of the buffer.
 800  * @param packet_size Size, in bytes, of a valid packet.
 801  * @param is_valid Callback that assesses whether the packet is valid or not.
 802  * @param timeout_ms The timeout after which, if no packet is detected, to
 803  *                   abort scanning.
 804  * @param baudrate The baudrate of the serial port. This parameter is not
 805  *                 critical, but it helps fine tune the serial port polling
 806  *                 delay.
 807  *
 808  * @return SR_OK if a valid packet is found within the given timeout,
 809  *         SR_ERR upon failure.
 810  */
 811 SR_PRIV int serial_stream_detect(struct sr_serial_dev_inst *serial,
 812                                  uint8_t *buf, size_t *buflen,
 813                                  size_t packet_size, packet_valid_t is_valid,
 814                                  uint64_t timeout_ms, int baudrate)
 815 {
 816         uint64_t start, time, byte_delay_us;
 817         size_t ibuf, i, maxlen;
 818         int len;
 819
 820         maxlen = *buflen;
 821
 822         sr_dbg("Detecting packets on FD %d (timeout = %" PRIu64
 823                "ms, baudrate = %d).", serial->fd, timeout_ms, baudrate);
 824
 825         if (maxlen < (packet_size / 2) ) {
 826                 sr_err("Buffer size must be at least twice the packet size.");
 827                 return SR_ERR;
 828         }
 829
 830         /* Assume 8n1 transmission. That is 10 bits for every byte. */
 831         byte_delay_us = 10 * (1000000 / baudrate);
 832         start = g_get_monotonic_time();
 833
 834         i = ibuf = len = 0;
 835         while (ibuf < maxlen) {
 836                 len = serial_read(serial, &buf[ibuf], 1);
 837                 if (len > 0) {
 838                         ibuf += len;
 839                 } else if (len == 0) {
 840                         /* No logging, already done in serial_read(). */
 841                 } else {
 842                         /* Error reading byte, but continuing anyway. */
 843                 }
 844
 845                 time = g_get_monotonic_time() - start;
 846                 time /= 1000;
 847
 848                 if ((ibuf - i) >= packet_size) {
 849                         /* We have at least a packet's worth of data. */
 850                         if (is_valid(&buf[i])) {
 851                                 sr_spew("Found valid %d-byte packet after "
 852                                         "%" PRIu64 "ms.", (ibuf - i), time);
 853                                 *buflen = ibuf;
 854                                 return SR_OK;
 855                         } else {
 856                                 sr_spew("Got %d bytes, but not a valid "
 857                                         "packet.", (ibuf - i));
 858                         }
 859                         /* Not a valid packet. Continue searching. */
 860                         i++;
 861                 }
 862                 if (time >= timeout_ms) {
 863                         /* Timeout */
 864                         sr_dbg("Detection timed out after %dms.", time);
 865                         break;
 866                 }
 867                 g_usleep(byte_delay_us);
 868         }
 869
 870         *buflen = ibuf;
 871
 872         sr_err("Didn't find a valid packet (read %d bytes).", *buflen);
 873
 874         return SR_ERR;
 875 }