Merge remote-tracking branch 'origin/5.7' into dev

Conflicts:
	.qmake.conf
	src/serialport/qserialport.cpp

Change-Id: I858fec6e426f5fd867b7eda7b1db69a2d447b357

12 files changed, 381 insertions, 235 deletions

diff --git a/LICENSE.GPLv2 b/LICENSE.GPLv2
index 6dbb032..a424477 100644
--- a/LICENSE.GPLv2
+++ b/LICENSE.GPLv2
@@ -3,7 +3,7 @@
  The Qt Toolkit is Copyright (C) 2015 The Qt Company Ltd.
  Contact: http://www.qt.io/licensing/
 
- You may use, distribute and copy the Qt GUI Toolkit under the terms of
+ You may use, distribute and copy the Qt Toolkit under the terms of
  GNU General Public License version 2, which is displayed below.
 
 -------------------------------------------------------------------------
diff --git a/LICENSE.GPLv3 b/LICENSE.GPLv3
index 4e49b12..71c4ad4 100644
--- a/LICENSE.GPLv3
+++ b/LICENSE.GPLv3
@@ -3,7 +3,7 @@
  The Qt Toolkit is Copyright (C) 2015 The Qt Company Ltd.
  Contact: http://www.qt.io/licensing/
 
- You may use, distribute and copy the Qt GUI Toolkit under the terms of
+ You may use, distribute and copy the Qt Toolkit under the terms of
  GNU Lesser General Public License version 3. That license references
  the General Public License version 3, that is displayed below. Other
  portions of the Qt Toolkit may be licensed directly under this license.
diff --git a/LICENSE.LGPLv21 b/LICENSE.LGPLv21
index 6e18461..dfcab5e 100644
--- a/LICENSE.LGPLv21
+++ b/LICENSE.LGPLv21
@@ -3,7 +3,7 @@
  The Qt Toolkit is Copyright (C) 2015 The Qt Company Ltd.
  Contact: http://www.qt.io/licensing/
 
- You may use, distribute and copy the Qt GUI Toolkit under the terms of
+ You may use, distribute and copy the Qt Toolkit under the terms of
  GNU Lesser General Public License version 2.1, which is displayed below.
 
 -------------------------------------------------------------------------
diff --git a/LICENSE.LGPLv3 b/LICENSE.LGPLv3
index 4d67bac..6bf924c 100644
--- a/LICENSE.LGPLv3
+++ b/LICENSE.LGPLv3
@@ -3,7 +3,7 @@
  The Qt Toolkit is Copyright (C) 2015 The Qt Company Ltd.
  Contact: http://www.qt.io/licensing/
 
- You may use, distribute and copy the Qt GUI Toolkit under the terms of
+ You may use, distribute and copy the Qt Toolkit under the terms of
  GNU Lesser General Public License version 3, which is displayed below.
  This license makes reference to the version 3 of the GNU General
  Public License, which you can find in the LICENSE.GPLv3 file.
diff --git a/dist/changes-5.6.1 b/dist/changes-5.6.1
new file mode 100644
index 0000000..d7bfb27
--- /dev/null
+++ b/dist/changes-5.6.1
@@ -0,0 +1,31 @@
+Qt 5.6.1 is a bug-fix release. It maintains both forward and backward
+compatibility (source and binary) with Qt 5.6.0.
+
+For more details, refer to the online documentation included in this
+distribution. The documentation is also available online:
+
+  http://doc.qt.io/qt-5/index.html
+
+The Qt version 5.6 series is binary compatible with the 5.5.x series.
+Applications compiled for 5.5 will continue to run with 5.6.
+
+Some of the changes listed in this file include issue tracking numbers
+corresponding to tasks in the Qt Bug Tracker:
+
+  https://bugreports.qt.io/
+
+Each of these identifiers can be entered in the bug tracker to obtain more
+information about a particular change.
+
+****************************************************************************
+*                          Library                                         *
+****************************************************************************
+
+ - QSerialPortInfo:
+   * Added enumeration of dial-in serial ports on FreeBSD.
+   * [QTBUG-50895] Added enumeration of dial-in serial ports on OS X.
+   * Added receiving of USB dongle's serial number on Windows.
+
+ - QSerialPort:
+   * Prohibited changing of RTS in HardwareFlowControl mode.
+   * [QTBUG-48677] Fixed reading of data remainder with the CDC USB device on Windows.
diff --git a/src/serialport/qserialport.cpp b/src/serialport/qserialport.cpp
index 4f3fd04..02a9422 100644
--- a/src/serialport/qserialport.cpp
+++ b/src/serialport/qserialport.cpp
@@ -109,7 +109,6 @@ QSerialPortPrivate::QSerialPortPrivate()
     , startAsyncWriteTimer(0)
     , originalEventMask(0)
     , triggeredEventMask(0)
-    , actualBytesToWrite(0)
 #elif defined(Q_OS_UNIX)
     , descriptor(-1)
     , readNotifier(0)
@@ -515,10 +514,6 @@ void QSerialPort::setPort(const QSerialPortInfo &serialPortInfo)
         \li Removes the prefix "\\\\.\\" or "//./" from the system location
            and returns the remainder of the string.
     \row
-        \li Windows CE
-        \li Removes the suffix ":" from the system location
-           and returns the remainder of the string.
-    \row
         \li Unix, BSD
         \li Removes the prefix "/dev/" from the system location
            and returns the remainder of the string.
@@ -568,15 +563,6 @@ bool QSerialPort::open(OpenMode mode)
     if (!d->open(mode))
         return false;
 
-    if (!d->setBaudRate()
-        || !d->setDataBits(d->dataBits)
-        || !d->setParity(d->parity)
-        || !d->setStopBits(d->stopBits)
-        || !d->setFlowControl(d->flowControl)) {
-        d->close();
-        return false;
-    }
-
     QIODevice::open(mode);
     return true;
 }
@@ -659,9 +645,9 @@ bool QSerialPort::settingsRestoredOnClose() const
     after that the opening of the port succeeds.
 
     \warning Setting the AllDirections flag is supported on all platforms.
-    Windows and Windows CE support only this mode.
+    Windows supports only this mode.
 
-    \warning Returns equal baud rate in any direction on Windows, Windows CE.
+    \warning Returns equal baud rate in any direction on Windows.
 
     The default value is Baud9600, i.e. 9600 bits per second.
 */
@@ -1261,11 +1247,8 @@ qint64 QSerialPort::bytesAvailable() const
 */
 qint64 QSerialPort::bytesToWrite() const
 {
-    qint64 bytes = QIODevice::bytesToWrite();
-#ifdef Q_OS_WIN32
-    bytes += d_func()->actualBytesToWrite;
-#endif
-    return bytes;
+    Q_D(const QSerialPort);
+    return QIODevice::bytesToWrite() + d->writeBuffer.size();
 }
 
 /*!
diff --git a/src/serialport/qserialport_p.h b/src/serialport/qserialport_p.h
index 923d524..10fda34 100644
--- a/src/serialport/qserialport_p.h
+++ b/src/serialport/qserialport_p.h
@@ -204,6 +204,7 @@ public:
     COMMTIMEOUTS restoredCommTimeouts;
     HANDLE handle;
     QByteArray readChunkBuffer;
+    QByteArray writeChunkBuffer;
     bool communicationStarted;
     bool writeStarted;
     bool readStarted;
@@ -214,7 +215,6 @@ public:
     OVERLAPPED writeCompletionOverlapped;
     DWORD originalEventMask;
     DWORD triggeredEventMask;
-    qint64 actualBytesToWrite;
 
 #elif defined(Q_OS_UNIX)
 
diff --git a/src/serialport/qserialport_unix.cpp b/src/serialport/qserialport_unix.cpp
index acc53c8..8e06ada 100644
--- a/src/serialport/qserialport_unix.cpp
+++ b/src/serialport/qserialport_unix.cpp
@@ -193,6 +193,120 @@ private:
     QSerialPortPrivate *dptr;
 };
 
+static inline void qt_set_common_props(termios *tio, QIODevice::OpenMode m)
+{
+#ifdef Q_OS_SOLARIS
+    tio->c_iflag &= ~(IMAXBEL|IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
+    tio->c_oflag &= ~OPOST;
+    tio->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
+    tio->c_cflag &= ~(CSIZE|PARENB);
+    tio->c_cflag |= CS8;
+#else
+    ::cfmakeraw(tio);
+#endif
+
+    tio->c_cflag |= CLOCAL;
+    tio->c_cc[VTIME] = 0;
+    tio->c_cc[VMIN] = 0;
+
+    if (m & QIODevice::ReadOnly)
+        tio->c_cflag |= CREAD;
+}
+
+static inline void qt_set_databits(termios *tio, QSerialPort::DataBits databits)
+{
+    tio->c_cflag &= ~CSIZE;
+    switch (databits) {
+    case QSerialPort::Data5:
+        tio->c_cflag |= CS5;
+        break;
+    case QSerialPort::Data6:
+        tio->c_cflag |= CS6;
+        break;
+    case QSerialPort::Data7:
+        tio->c_cflag |= CS7;
+        break;
+    case QSerialPort::Data8:
+        tio->c_cflag |= CS8;
+        break;
+    default:
+        tio->c_cflag |= CS8;
+        break;
+    }
+}
+
+static inline void qt_set_parity(termios *tio, QSerialPort::Parity parity)
+{
+    tio->c_iflag &= ~(PARMRK | INPCK);
+    tio->c_iflag |= IGNPAR;
+
+    switch (parity) {
+
+#ifdef CMSPAR
+    // Here Installation parity only for GNU/Linux where the macro CMSPAR.
+    case QSerialPort::SpaceParity:
+        tio->c_cflag &= ~PARODD;
+        tio->c_cflag |= PARENB | CMSPAR;
+        break;
+    case QSerialPort::MarkParity:
+        tio->c_cflag |= PARENB | CMSPAR | PARODD;
+        break;
+#endif
+    case QSerialPort::NoParity:
+        tio->c_cflag &= ~PARENB;
+        break;
+    case QSerialPort::EvenParity:
+        tio->c_cflag &= ~PARODD;
+        tio->c_cflag |= PARENB;
+        break;
+    case QSerialPort::OddParity:
+        tio->c_cflag |= PARENB | PARODD;
+        break;
+    default:
+        tio->c_cflag |= PARENB;
+        tio->c_iflag |= PARMRK | INPCK;
+        tio->c_iflag &= ~IGNPAR;
+        break;
+    }
+}
+
+static inline void qt_set_stopbits(termios *tio, QSerialPort::StopBits stopbits)
+{
+    switch (stopbits) {
+    case QSerialPort::OneStop:
+        tio->c_cflag &= ~CSTOPB;
+        break;
+    case QSerialPort::TwoStop:
+        tio->c_cflag |= CSTOPB;
+        break;
+    default:
+        tio->c_cflag &= ~CSTOPB;
+        break;
+    }
+}
+
+static inline void qt_set_flowcontrol(termios *tio, QSerialPort::FlowControl flowcontrol)
+{
+    switch (flowcontrol) {
+    case QSerialPort::NoFlowControl:
+        tio->c_cflag &= ~CRTSCTS;
+        tio->c_iflag &= ~(IXON | IXOFF | IXANY);
+        break;
+    case QSerialPort::HardwareControl:
+        tio->c_cflag |= CRTSCTS;
+        tio->c_iflag &= ~(IXON | IXOFF | IXANY);
+        break;
+    case QSerialPort::SoftwareControl:
+        tio->c_cflag &= ~CRTSCTS;
+        tio->c_iflag |= IXON | IXOFF | IXANY;
+        break;
+    default:
+        tio->c_cflag &= ~CRTSCTS;
+        tio->c_iflag &= ~(IXON | IXOFF | IXANY);
+        break;
+    }
+}
+
 bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
 {
     QString lockFilePath = serialPortLockFilePath(QSerialPortInfoPrivate::portNameFromSystemLocation(systemLocation));
@@ -605,24 +719,8 @@ bool QSerialPortPrivate::setDataBits(QSerialPort::DataBits dataBits)
     if (!getTermios(&tio))
         return false;
 
-    tio.c_cflag &= ~CSIZE;
-    switch (dataBits) {
-    case QSerialPort::Data5:
-        tio.c_cflag |= CS5;
-        break;
-    case QSerialPort::Data6:
-        tio.c_cflag |= CS6;
-        break;
-    case QSerialPort::Data7:
-        tio.c_cflag |= CS7;
-        break;
-    case QSerialPort::Data8:
-        tio.c_cflag |= CS8;
-        break;
-    default:
-        tio.c_cflag |= CS8;
-        break;
-    }
+    qt_set_databits(&tio, dataBits);
+
     return setTermios(&tio);
 }
 
@@ -632,37 +730,7 @@ bool QSerialPortPrivate::setParity(QSerialPort::Parity parity)
     if (!getTermios(&tio))
         return false;
 
-    tio.c_iflag &= ~(PARMRK | INPCK);
-    tio.c_iflag |= IGNPAR;
-
-    switch (parity) {
-
-#ifdef CMSPAR
-    // Here Installation parity only for GNU/Linux where the macro CMSPAR.
-    case QSerialPort::SpaceParity:
-        tio.c_cflag &= ~PARODD;
-        tio.c_cflag |= PARENB | CMSPAR;
-        break;
-    case QSerialPort::MarkParity:
-        tio.c_cflag |= PARENB | CMSPAR | PARODD;
-        break;
-#endif
-    case QSerialPort::NoParity:
-        tio.c_cflag &= ~PARENB;
-        break;
-    case QSerialPort::EvenParity:
-        tio.c_cflag &= ~PARODD;
-        tio.c_cflag |= PARENB;
-        break;
-    case QSerialPort::OddParity:
-        tio.c_cflag |= PARENB | PARODD;
-        break;
-    default:
-        tio.c_cflag |= PARENB;
-        tio.c_iflag |= PARMRK | INPCK;
-        tio.c_iflag &= ~IGNPAR;
-        break;
-    }
+    qt_set_parity(&tio, parity);
 
     return setTermios(&tio);
 }
@@ -673,17 +741,8 @@ bool QSerialPortPrivate::setStopBits(QSerialPort::StopBits stopBits)
     if (!getTermios(&tio))
         return false;
 
-    switch (stopBits) {
-    case QSerialPort::OneStop:
-        tio.c_cflag &= ~CSTOPB;
-        break;
-    case QSerialPort::TwoStop:
-        tio.c_cflag |= CSTOPB;
-        break;
-    default:
-        tio.c_cflag &= ~CSTOPB;
-        break;
-    }
+    qt_set_stopbits(&tio, stopBits);
+
     return setTermios(&tio);
 }
 
@@ -693,24 +752,8 @@ bool QSerialPortPrivate::setFlowControl(QSerialPort::FlowControl flowControl)
     if (!getTermios(&tio))
         return false;
 
-    switch (flowControl) {
-    case QSerialPort::NoFlowControl:
-        tio.c_cflag &= ~CRTSCTS;
-        tio.c_iflag &= ~(IXON | IXOFF | IXANY);
-        break;
-    case QSerialPort::HardwareControl:
-        tio.c_cflag |= CRTSCTS;
-        tio.c_iflag &= ~(IXON | IXOFF | IXANY);
-        break;
-    case QSerialPort::SoftwareControl:
-        tio.c_cflag &= ~CRTSCTS;
-        tio.c_iflag |= IXON | IXOFF | IXANY;
-        break;
-    default:
-        tio.c_cflag &= ~CRTSCTS;
-        tio.c_iflag &= ~(IXON | IXOFF | IXANY);
-        break;
-    }
+    qt_set_flowcontrol(&tio, flowControl);
+
     return setTermios(&tio);
 }
 
@@ -825,25 +868,19 @@ inline bool QSerialPortPrivate::initialize(QIODevice::OpenMode mode)
         return false;
 
     restoredTermios = tio;
-#ifdef Q_OS_SOLARIS
-    tio.c_iflag &= ~(IMAXBEL|IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
-    tio.c_oflag &= ~OPOST;
-    tio.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
-    tio.c_cflag &= ~(CSIZE|PARENB);
-    tio.c_cflag |= CS8;
-#else
-    ::cfmakeraw(&tio);
-#endif
-    tio.c_cflag |= CLOCAL;
-    tio.c_cc[VTIME] = 0;
-    tio.c_cc[VMIN] = 0;
 
-    if (mode & QIODevice::ReadOnly)
-        tio.c_cflag |= CREAD;
+    qt_set_common_props(&tio, mode);
+    qt_set_databits(&tio, dataBits);
+    qt_set_parity(&tio, parity);
+    qt_set_stopbits(&tio, stopBits);
+    qt_set_flowcontrol(&tio, flowControl);
 
     if (!setTermios(&tio))
         return false;
 
+    if (!setBaudRate())
+        return false;
+
     if (mode & QIODevice::ReadOnly)
         setReadNotificationEnabled(true);
 
@@ -852,7 +889,7 @@ inline bool QSerialPortPrivate::initialize(QIODevice::OpenMode mode)
 
 qint64 QSerialPortPrivate::writeData(const char *data, qint64 maxSize)
 {
-    ::memcpy(writeBuffer.reserve(maxSize), data, maxSize);
+    writeBuffer.append(data, maxSize);
     if (!writeBuffer.isEmpty() && !isWriteNotificationEnabled())
         setWriteNotificationEnabled(true);
     return maxSize;
diff --git a/src/serialport/qserialport_win.cpp b/src/serialport/qserialport_win.cpp
index 7cbb81d..9ab4448 100644
--- a/src/serialport/qserialport_win.cpp
+++ b/src/serialport/qserialport_win.cpp
@@ -81,6 +81,94 @@
 
 QT_BEGIN_NAMESPACE
 
+static inline void qt_set_common_props(DCB *dcb)
+{
+    dcb->fBinary = TRUE;
+    dcb->fAbortOnError = FALSE;
+    dcb->fNull = FALSE;
+    dcb->fErrorChar = FALSE;
+
+    if (dcb->fDtrControl == DTR_CONTROL_HANDSHAKE)
+        dcb->fDtrControl = DTR_CONTROL_DISABLE;
+}
+
+static inline void qt_set_baudrate(DCB *dcb, qint32 baudrate)
+{
+    dcb->BaudRate = baudrate;
+}
+
+static inline void qt_set_databits(DCB *dcb, QSerialPort::DataBits databits)
+{
+    dcb->ByteSize = databits;
+}
+
+static inline void qt_set_parity(DCB *dcb, QSerialPort::Parity parity)
+{
+    dcb->fParity = TRUE;
+    switch (parity) {
+    case QSerialPort::NoParity:
+        dcb->Parity = NOPARITY;
+        dcb->fParity = FALSE;
+        break;
+    case QSerialPort::OddParity:
+        dcb->Parity = ODDPARITY;
+        break;
+    case QSerialPort::EvenParity:
+        dcb->Parity = EVENPARITY;
+        break;
+    case QSerialPort::MarkParity:
+        dcb->Parity = MARKPARITY;
+        break;
+    case QSerialPort::SpaceParity:
+        dcb->Parity = SPACEPARITY;
+        break;
+    default:
+        dcb->Parity = NOPARITY;
+        dcb->fParity = FALSE;
+        break;
+    }
+}
+
+static inline void qt_set_stopbits(DCB *dcb, QSerialPort::StopBits stopbits)
+{
+    switch (stopbits) {
+    case QSerialPort::OneStop:
+        dcb->StopBits = ONESTOPBIT;
+        break;
+    case QSerialPort::OneAndHalfStop:
+        dcb->StopBits = ONE5STOPBITS;
+        break;
+    case QSerialPort::TwoStop:
+        dcb->StopBits = TWOSTOPBITS;
+        break;
+    default:
+        dcb->StopBits = ONESTOPBIT;
+        break;
+    }
+}
+
+static inline void qt_set_flowcontrol(DCB *dcb, QSerialPort::FlowControl flowcontrol)
+{
+    dcb->fInX = FALSE;
+    dcb->fOutX = FALSE;
+    dcb->fOutxCtsFlow = FALSE;
+    dcb->fRtsControl = RTS_CONTROL_DISABLE;
+    switch (flowcontrol) {
+    case QSerialPort::NoFlowControl:
+        break;
+    case QSerialPort::SoftwareControl:
+        dcb->fInX = TRUE;
+        dcb->fOutX = TRUE;
+        break;
+    case QSerialPort::HardwareControl:
+        dcb->fOutxCtsFlow = TRUE;
+        dcb->fRtsControl = RTS_CONTROL_HANDSHAKE;
+        break;
+    default:
+        break;
+    }
+}
+
 bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
 {
     DWORD desiredAccess = 0;
@@ -122,7 +210,6 @@ void QSerialPortPrivate::close()
     readStarted = false;
     writeStarted = false;
     writeBuffer.clear();
-    actualBytesToWrite = 0;
 
     if (settingsRestoredOnClose) {
         ::SetCommState(handle, &restoredDcb);
@@ -204,10 +291,8 @@ bool QSerialPortPrivate::clear(QSerialPort::Directions directions)
     DWORD flags = 0;
     if (directions & QSerialPort::Input)
         flags |= PURGE_RXABORT | PURGE_RXCLEAR;
-    if (directions & QSerialPort::Output) {
+    if (directions & QSerialPort::Output)
         flags |= PURGE_TXABORT | PURGE_TXCLEAR;
-        actualBytesToWrite = 0;
-    }
     if (!::PurgeComm(handle, flags)) {
         setError(getSystemError());
         return false;
@@ -281,7 +366,7 @@ bool QSerialPortPrivate::waitForReadyRead(int msecs)
 
 bool QSerialPortPrivate::waitForBytesWritten(int msecs)
 {
-    if (writeBuffer.isEmpty())
+    if (writeBuffer.isEmpty() && writeChunkBuffer.isEmpty())
         return false;
 
     if (!writeStarted && !_q_startAsyncWrite())
@@ -319,7 +404,8 @@ bool QSerialPortPrivate::setBaudRate(qint32 baudRate, QSerialPort::Directions di
     if (!getDcb(&dcb))
         return false;
 
-    dcb.BaudRate = baudRate;
+    qt_set_baudrate(&dcb, baudRate);
+
     return setDcb(&dcb);
 }
 
@@ -329,7 +415,8 @@ bool QSerialPortPrivate::setDataBits(QSerialPort::DataBits dataBits)
     if (!getDcb(&dcb))
         return false;
 
-    dcb.ByteSize = dataBits;
+    qt_set_databits(&dcb, dataBits);
+
     return setDcb(&dcb);
 }
 
@@ -339,29 +426,8 @@ bool QSerialPortPrivate::setParity(QSerialPort::Parity parity)
     if (!getDcb(&dcb))
         return false;
 
-    dcb.fParity = TRUE;
-    switch (parity) {
-    case QSerialPort::NoParity:
-        dcb.Parity = NOPARITY;
-        dcb.fParity = FALSE;
-        break;
-    case QSerialPort::OddParity:
-        dcb.Parity = ODDPARITY;
-        break;
-    case QSerialPort::EvenParity:
-        dcb.Parity = EVENPARITY;
-        break;
-    case QSerialPort::MarkParity:
-        dcb.Parity = MARKPARITY;
-        break;
-    case QSerialPort::SpaceParity:
-        dcb.Parity = SPACEPARITY;
-        break;
-    default:
-        dcb.Parity = NOPARITY;
-        dcb.fParity = FALSE;
-        break;
-    }
+    qt_set_parity(&dcb, parity);
+
     return setDcb(&dcb);
 }
 
@@ -371,20 +437,8 @@ bool QSerialPortPrivate::setStopBits(QSerialPort::StopBits stopBits)
     if (!getDcb(&dcb))
         return false;
 
-    switch (stopBits) {
-    case QSerialPort::OneStop:
-        dcb.StopBits = ONESTOPBIT;
-        break;
-    case QSerialPort::OneAndHalfStop:
-        dcb.StopBits = ONE5STOPBITS;
-        break;
-    case QSerialPort::TwoStop:
-        dcb.StopBits = TWOSTOPBITS;
-        break;
-    default:
-        dcb.StopBits = ONESTOPBIT;
-        break;
-    }
+    qt_set_stopbits(&dcb, stopBits);
+
     return setDcb(&dcb);
 }
 
@@ -394,24 +448,8 @@ bool QSerialPortPrivate::setFlowControl(QSerialPort::FlowControl flowControl)
     if (!getDcb(&dcb))
         return false;
 
-    dcb.fInX = FALSE;
-    dcb.fOutX = FALSE;
-    dcb.fOutxCtsFlow = FALSE;
-    dcb.fRtsControl = RTS_CONTROL_DISABLE;
-    switch (flowControl) {
-    case QSerialPort::NoFlowControl:
-        break;
-    case QSerialPort::SoftwareControl:
-        dcb.fInX = TRUE;
-        dcb.fOutX = TRUE;
-        break;
-    case QSerialPort::HardwareControl:
-        dcb.fOutxCtsFlow = TRUE;
-        dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
-        break;
-    default:
-        break;
-    }
+    qt_set_flowcontrol(&dcb, flowControl);
+
     return setDcb(&dcb);
 }
 
@@ -431,10 +469,8 @@ bool QSerialPortPrivate::completeAsyncRead(qint64 bytesTransferred)
         readStarted = false;
         return false;
     }
-    if (bytesTransferred > 0) {
-        char *ptr = buffer.reserve(bytesTransferred);
-        ::memcpy(ptr, readChunkBuffer.constData(), bytesTransferred);
-    }
+    if (bytesTransferred > 0)
+        buffer.append(readChunkBuffer.constData(), bytesTransferred);
 
     readStarted = false;
 
@@ -459,12 +495,13 @@ bool QSerialPortPrivate::completeAsyncWrite(qint64 bytesTransferred)
 
     if (writeStarted) {
         if (bytesTransferred == qint64(-1)) {
+            writeChunkBuffer.clear();
             writeStarted = false;
             return false;
-        } else if (bytesTransferred > 0) {
-            writeBuffer.free(bytesTransferred);
-            emit q->bytesWritten(bytesTransferred);
         }
+        Q_ASSERT(bytesTransferred == writeChunkBuffer.size());
+        writeChunkBuffer.clear();
+        emit q->bytesWritten(bytesTransferred);
         writeStarted = false;
     }
 
@@ -531,10 +568,10 @@ bool QSerialPortPrivate::_q_startAsyncWrite()
     if (writeBuffer.isEmpty() || writeStarted)
         return true;
 
-    const int writeBytes = writeBuffer.nextDataBlockSize();
+    writeChunkBuffer = writeBuffer.read();
     ::ZeroMemory(&writeCompletionOverlapped, sizeof(writeCompletionOverlapped));
-    if (!::WriteFile(handle, writeBuffer.readPointer(),
-                     writeBytes, nullptr, &writeCompletionOverlapped)) {
+    if (!::WriteFile(handle, writeChunkBuffer.constData(),
+                     writeChunkBuffer.size(), nullptr, &writeCompletionOverlapped)) {
 
         QSerialPortErrorInfo error = getSystemError();
         if (error.errorCode != QSerialPort::NoError) {
@@ -545,7 +582,6 @@ bool QSerialPortPrivate::_q_startAsyncWrite()
         }
     }
 
-    actualBytesToWrite -= writeBytes;
     writeStarted = true;
     return true;
 }
@@ -579,8 +615,7 @@ qint64 QSerialPortPrivate::writeData(const char *data, qint64 maxSize)
 {
     Q_Q(QSerialPort);
 
-    ::memcpy(writeBuffer.reserve(maxSize), data, maxSize);
-    actualBytesToWrite += maxSize;
+    writeBuffer.append(data, maxSize);
 
     if (!writeBuffer.isEmpty() && !writeStarted) {
         if (!startAsyncWriteTimer) {
@@ -588,7 +623,8 @@ qint64 QSerialPortPrivate::writeData(const char *data, qint64 maxSize)
             QObjectPrivate::connect(startAsyncWriteTimer, &QTimer::timeout, this, &QSerialPortPrivate::_q_startAsyncWrite);
             startAsyncWriteTimer->setSingleShot(true);
         }
-        startAsyncWriteTimer->start(0);
+        if (!startAsyncWriteTimer->isActive())
+            startAsyncWriteTimer->start();
     }
     return maxSize;
 }
@@ -623,17 +659,12 @@ inline bool QSerialPortPrivate::initialize()
 
     restoredDcb = dcb;
 
-    dcb.fBinary = TRUE;
-    dcb.fInX = FALSE;
-    dcb.fOutX = FALSE;
-    dcb.fAbortOnError = FALSE;
-    dcb.fNull = FALSE;
-    dcb.fErrorChar = FALSE;
-
-    if (dcb.fDtrControl == DTR_CONTROL_HANDSHAKE)
-        dcb.fDtrControl = DTR_CONTROL_DISABLE;
-
-    dcb.BaudRate = inputBaudRate;
+    qt_set_common_props(&dcb);
+    qt_set_baudrate(&dcb, inputBaudRate);
+    qt_set_databits(&dcb, dataBits);
+    qt_set_parity(&dcb, parity);
+    qt_set_stopbits(&dcb, stopBits);
+    qt_set_flowcontrol(&dcb, flowControl);
 
     if (!setDcb(&dcb))
         return false;
diff --git a/src/serialport/qserialportinfo.cpp b/src/serialport/qserialportinfo.cpp
index 2b69966..d978665 100644
--- a/src/serialport/qserialportinfo.cpp
+++ b/src/serialport/qserialportinfo.cpp
@@ -87,14 +87,8 @@ QSerialPortInfo::QSerialPortInfo(const QSerialPortInfo &other)
     Constructs a QSerialPortInfo object from serial \a port.
 */
 QSerialPortInfo::QSerialPortInfo(const QSerialPort &port)
+    : QSerialPortInfo(port.portName())
 {
-    const auto infos = QSerialPortInfo::availablePorts();
-    for (const QSerialPortInfo &info : infos) {
-        if (port.portName() == info.portName()) {
-            *this = info;
-            break;
-        }
-    }
 }
 
 /*!
diff --git a/src/serialport/qserialportinfo_win.cpp b/src/serialport/qserialportinfo_win.cpp
index 398666e..1bab3e9 100644
--- a/src/serialport/qserialportinfo_win.cpp
+++ b/src/serialport/qserialportinfo_win.cpp
@@ -187,23 +187,6 @@ static QString devicePortName(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInf
     return portName;
 }
 
-class SerialPortNameEqualFunctor
-{
-public:
-    explicit SerialPortNameEqualFunctor(const QString &serialPortName)
-        : m_serialPortName(serialPortName)
-    {
-    }
-
-    bool operator() (const QSerialPortInfo &serialPortInfo) const
-    {
-        return serialPortInfo.portName() == m_serialPortName;
-    }
-
-private:
-    const QString &m_serialPortName;
-};
-
 static QString deviceDescription(HDEVINFO deviceInfoSet,
                                  PSP_DEVINFO_DATA deviceInfoData)
 {
@@ -288,6 +271,15 @@ static QString deviceSerialNumber(QString instanceIdentifier,
     return QString();
 }
 
+static bool anyOfPorts(const QList<QSerialPortInfo> &ports, const QString &portName)
+{
+    const auto end = ports.end();
+    auto isPortNamesEquals = [&portName](const QSerialPortInfo &portInfo) {
+        return portInfo.portName() == portName;
+    };
+    return std::find_if(ports.begin(), end, isPortNamesEquals) != end;
+}
+
 QList<QSerialPortInfo> QSerialPortInfo::availablePorts()
 {
     static const struct {
@@ -318,10 +310,8 @@ QList<QSerialPortInfo> QSerialPortInfo::availablePorts()
             if (portName.isEmpty() || portName.contains(QLatin1String("LPT")))
                 continue;
 
-            if (std::find_if(serialPortInfoList.begin(), serialPortInfoList.end(),
-                             SerialPortNameEqualFunctor(portName)) != serialPortInfoList.end()) {
+            if (anyOfPorts(serialPortInfoList, portName))
                 continue;
-            }
 
             QSerialPortInfoPrivate priv;
 
@@ -346,8 +336,7 @@ QList<QSerialPortInfo> QSerialPortInfo::availablePorts()
 
     const auto portNames = portNamesFromHardwareDeviceMap();
     for (const QString &portName : portNames) {
-        if (std::find_if(serialPortInfoList.cbegin(), serialPortInfoList.cend(),
-                         SerialPortNameEqualFunctor(portName)) == serialPortInfoList.cend()) {
+        if (!anyOfPorts(serialPortInfoList, portName)) {
             QSerialPortInfoPrivate priv;
             priv.portName = portName;
             priv.device =  QSerialPortInfoPrivate::portNameToSystemLocation(portName);
diff --git a/tests/auto/qserialport/tst_qserialport.cpp b/tests/auto/qserialport/tst_qserialport.cpp
index 24c0134..33a48fe 100644
--- a/tests/auto/qserialport/tst_qserialport.cpp
+++ b/tests/auto/qserialport/tst_qserialport.cpp
@@ -96,6 +96,9 @@ private slots:
     void flowControl_data();
     void flowControl();
 
+    void rts();
+    void dtr();
+
     void flush();
     void doubleFlush();
 
@@ -149,6 +152,7 @@ const QByteArray tst_QSerialPort::newlineArray("\n\r");
 
 tst_QSerialPort::tst_QSerialPort()
 {
+    qRegisterMetaType<QSerialPort::SerialPortError>("QSerialPort::SerialPortError");
 }
 
 void tst_QSerialPort::initTestCase()
@@ -468,6 +472,83 @@ void tst_QSerialPort::flowControl()
     }
 }
 
+void tst_QSerialPort::rts()
+{
+    QSerialPort serialPort(m_senderPortName);
+
+    QSignalSpy errorSpy(&serialPort, static_cast<void (QSerialPort::*)(QSerialPort::SerialPortError)>(&QSerialPort::error));
+    QVERIFY(errorSpy.isValid());
+    QSignalSpy rtsSpy(&serialPort, &QSerialPort::requestToSendChanged);
+    QVERIFY(rtsSpy.isValid());
+
+    QVERIFY(serialPort.open(QIODevice::ReadWrite));
+
+    // no flow control
+    QVERIFY(serialPort.setFlowControl(QSerialPort::NoFlowControl));
+    const bool toggle1 = !serialPort.isRequestToSend();
+    QVERIFY(serialPort.setRequestToSend(toggle1));
+    QCOMPARE(serialPort.isRequestToSend(), toggle1);
+
+    // software flow control
+    QVERIFY(serialPort.setFlowControl(QSerialPort::SoftwareControl));
+    const bool toggle2 = !serialPort.isRequestToSend();
+    QVERIFY(serialPort.setRequestToSend(toggle2));
+    QCOMPARE(serialPort.isRequestToSend(), toggle2);
+
+    // hardware flow control
+    QVERIFY(serialPort.setFlowControl(QSerialPort::HardwareControl));
+    const bool toggle3 = !serialPort.isRequestToSend();
+    QVERIFY(!serialPort.setRequestToSend(toggle3)); // not allowed
+    QCOMPARE(serialPort.isRequestToSend(), !toggle3); // same as before
+    QCOMPARE(serialPort.error(), QSerialPort::UnsupportedOperationError);
+
+    QCOMPARE(errorSpy.count(), 2);
+    QCOMPARE(qvariant_cast<QSerialPort::SerialPortError>(errorSpy.at(0).at(0)), QSerialPort::NoError);
+    QCOMPARE(qvariant_cast<QSerialPort::SerialPortError>(errorSpy.at(1).at(0)), QSerialPort::UnsupportedOperationError);
+
+    QCOMPARE(rtsSpy.count(), 2);
+    QCOMPARE(qvariant_cast<bool>(rtsSpy.at(0).at(0)), toggle1);
+    QCOMPARE(qvariant_cast<bool>(rtsSpy.at(1).at(0)), toggle2);
+}
+
+void tst_QSerialPort::dtr()
+{
+    QSerialPort serialPort(m_senderPortName);
+
+    QSignalSpy errorSpy(&serialPort, static_cast<void (QSerialPort::*)(QSerialPort::SerialPortError)>(&QSerialPort::error));
+    QVERIFY(errorSpy.isValid());
+    QSignalSpy dtrSpy(&serialPort, &QSerialPort::dataTerminalReadyChanged);
+    QVERIFY(dtrSpy.isValid());
+
+    QVERIFY(serialPort.open(QIODevice::ReadWrite));
+
+    // no flow control
+    QVERIFY(serialPort.setFlowControl(QSerialPort::NoFlowControl));
+    const bool toggle1 = !serialPort.isDataTerminalReady();
+    QVERIFY(serialPort.setDataTerminalReady(toggle1));
+    QCOMPARE(serialPort.isDataTerminalReady(), toggle1);
+
+    // software flow control
+    QVERIFY(serialPort.setFlowControl(QSerialPort::SoftwareControl));
+    const bool toggle2 = !serialPort.isDataTerminalReady();
+    QVERIFY(serialPort.setDataTerminalReady(toggle2));
+    QCOMPARE(serialPort.isDataTerminalReady(), toggle2);
+
+    // hardware flow control
+    QVERIFY(serialPort.setFlowControl(QSerialPort::HardwareControl));
+    const bool toggle3 = !serialPort.isDataTerminalReady();
+    QVERIFY(serialPort.setDataTerminalReady(toggle3));
+    QCOMPARE(serialPort.isDataTerminalReady(), toggle3);
+
+    QCOMPARE(errorSpy.count(), 1);
+    QCOMPARE(qvariant_cast<QSerialPort::SerialPortError>(errorSpy.at(0).at(0)), QSerialPort::NoError);
+
+    QCOMPARE(dtrSpy.count(), 3);
+    QCOMPARE(qvariant_cast<bool>(dtrSpy.at(0).at(0)), toggle1);
+    QCOMPARE(qvariant_cast<bool>(dtrSpy.at(1).at(0)), toggle2);
+    QCOMPARE(qvariant_cast<bool>(dtrSpy.at(2).at(0)), toggle3);
+}
+
 void tst_QSerialPort::handleBytesWrittenAndExitLoopSlot(qint64 bytesWritten)
 {
     QCOMPARE(bytesWritten, qint64(alphabetArray.size() + newlineArray.size()));