Set serial connection parameters immediately on connect.

device/serial/serial_io_handler_win.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <windows.h>
 
 #include "device/serial/serial_io_handler_win.h"
 
 namespace device {
 
@@ skipping 149 matching lines @@
   write_context_->handler = this;
   memset(&write_context_->overlapped, 0, sizeof(write_context_->overlapped));
 
   // A ReadIntervalTimeout of MAXDWORD will cause async reads to complete
   // immediately with any data that's available, even if there is none.
   // This is OK because we never issue a read request until WaitCommEvent
   // signals that data is available.
   COMMTIMEOUTS timeouts = {0};
   timeouts.ReadIntervalTimeout = MAXDWORD;
   if (!::SetCommTimeouts(file().GetPlatformFile(), &timeouts)) {
+    VPLOG(1) << "Failed to set serial timeouts";
     return false;
   }
 
-  DCB config = {0};
-  config.DCBlength = sizeof(config);
-  if (!GetCommState(file().GetPlatformFile(), &config)) {
-    return false;
-  }
-  // Setup some sane default state.
-  config.fBinary = TRUE;
-  config.fParity = FALSE;
-  config.fAbortOnError = TRUE;
-  config.fOutxCtsFlow = FALSE;
-  config.fOutxDsrFlow = FALSE;
-  config.fRtsControl = RTS_CONTROL_ENABLE;
-  config.fDtrControl = DTR_CONTROL_ENABLE;
-  config.fDsrSensitivity = FALSE;
-  config.fOutX = FALSE;
-  config.fInX = FALSE;
-  return SetCommState(file().GetPlatformFile(), &config) != 0;
+  return true;
 }
 
 void SerialIoHandlerWin::ReadImpl() {
   DCHECK(CalledOnValidThread());
   DCHECK(pending_read_buffer());
   DCHECK(file().IsValid());
 
   DWORD errors;
   COMSTAT status;
   if (!ClearCommError(file().GetPlatformFile(), &errors, &status) ||
       errors != 0) {
     QueueReadCompleted(0, serial::RECEIVE_ERROR_SYSTEM_ERROR);
     return;
   }
 
-  SetCommMask(file().GetPlatformFile(), EV_RXCHAR);
+  if (!SetCommMask(file().GetPlatformFile(), EV_RXCHAR)) {
+    VPLOG(1) << "Failed to set serial event flags";
+  }
 
   event_mask_ = 0;
   BOOL ok = ::WaitCommEvent(
       file().GetPlatformFile(), &event_mask_, &comm_context_->overlapped);
   if (!ok && GetLastError() != ERROR_IO_PENDING) {
+    VPLOG(1) << "Failed to receive serial event";
     QueueReadCompleted(0, serial::RECEIVE_ERROR_SYSTEM_ERROR);
   }
   is_comm_pending_ = true;
 }
 
 void SerialIoHandlerWin::WriteImpl() {
   DCHECK(CalledOnValidThread());
   DCHECK(pending_write_buffer());
   DCHECK(file().IsValid());
 
@@ skipping 12 matching lines @@
   DCHECK(file().IsValid());
   ::CancelIo(file().GetPlatformFile());
 }
 
 void SerialIoHandlerWin::CancelWriteImpl() {
   DCHECK(CalledOnValidThread());
   DCHECK(file().IsValid());
   ::CancelIo(file().GetPlatformFile());
 }
 
+bool SerialIoHandlerWin::ConfigurePortImpl() {
+  DCB config = {0};
+  config.DCBlength = sizeof(config);
+  if (!GetCommState(file().GetPlatformFile(), &config)) {
+    VPLOG(1) << "Failed to get serial port info";
+    return false;
+  }
+
+  // Set up some sane default options that are not configurable.
+  config.fBinary = TRUE;
+  config.fParity = FALSE;
+  config.fAbortOnError = TRUE;
+  config.fOutxDsrFlow = FALSE;
+  config.fDtrControl = DTR_CONTROL_ENABLE;
+  config.fDsrSensitivity = FALSE;
+  config.fOutX = FALSE;
+  config.fInX = FALSE;
+
+  DCHECK(options().bitrate);
+  config.BaudRate = BitrateToSpeedConstant(options().bitrate);
+
+  DCHECK(options().data_bits != serial::DATA_BITS_NONE);
+  config.ByteSize = DataBitsEnumToConstant(options().data_bits);
+
+  DCHECK(options().parity_bit != serial::PARITY_BIT_NONE);
+  config.Parity = ParityBitEnumToConstant(options().parity_bit);
+
+  DCHECK(options().stop_bits != serial::STOP_BITS_NONE);
+  config.StopBits = StopBitsEnumToConstant(options().stop_bits);
+
+  DCHECK(options().has_cts_flow_control);
+  if (options().cts_flow_control) {
+    config.fOutxCtsFlow = TRUE;
+    config.fRtsControl = RTS_CONTROL_HANDSHAKE;
+  } else {
+    config.fOutxCtsFlow = FALSE;
+    config.fRtsControl = RTS_CONTROL_ENABLE;
+  }
+
+  if (!SetCommState(file().GetPlatformFile(), &config)) {
+    VPLOG(1) << "Failed to set serial port info";
+    return false;
+  }
+  return true;
+}
+
 SerialIoHandlerWin::SerialIoHandlerWin(
     scoped_refptr<base::MessageLoopProxy> file_thread_message_loop,
     scoped_refptr<base::MessageLoopProxy> ui_thread_message_loop)
     : SerialIoHandler(file_thread_message_loop, ui_thread_message_loop),
       event_mask_(0),
       is_comm_pending_(false) {
 }
 
 SerialIoHandlerWin::~SerialIoHandlerWin() {
 }
@@ skipping 38 matching lines @@
     } else {
       WriteCompleted(bytes_transferred,
                      error == ERROR_SUCCESS ? serial::SEND_ERROR_NONE
                                             : serial::SEND_ERROR_SYSTEM_ERROR);
     }
   } else {
     NOTREACHED() << "Invalid IOContext";
   }
 }
 
-bool SerialIoHandlerWin::ConfigurePort(
-    const serial::ConnectionOptions& options) {
-  DCB config = {0};
-  config.DCBlength = sizeof(config);
-  if (!GetCommState(file().GetPlatformFile(), &config)) {
+bool SerialIoHandlerWin::Flush() const {
+  if (!PurgeComm(file().GetPlatformFile(), PURGE_RXCLEAR | PURGE_TXCLEAR)) {
+    VPLOG(1) << "Failed to flush serial port";
     return false;
   }
-  if (options.bitrate)
-    config.BaudRate = BitrateToSpeedConstant(options.bitrate);
-  if (options.data_bits != serial::DATA_BITS_NONE)
-    config.ByteSize = DataBitsEnumToConstant(options.data_bits);
-  if (options.parity_bit != serial::PARITY_BIT_NONE)
-    config.Parity = ParityBitEnumToConstant(options.parity_bit);
-  if (options.stop_bits != serial::STOP_BITS_NONE)
-    config.StopBits = StopBitsEnumToConstant(options.stop_bits);
-  if (options.has_cts_flow_control) {
-    if (options.cts_flow_control) {
-      config.fOutxCtsFlow = TRUE;
-      config.fRtsControl = RTS_CONTROL_HANDSHAKE;
-    } else {
-      config.fOutxCtsFlow = FALSE;
-      config.fRtsControl = RTS_CONTROL_ENABLE;
-    }
-  }
-  return SetCommState(file().GetPlatformFile(), &config) != 0;
-}
-
-bool SerialIoHandlerWin::Flush() const {
-  return PurgeComm(file().GetPlatformFile(), PURGE_RXCLEAR | PURGE_TXCLEAR) !=
-         0;
+  return true;
 }
 
 serial::DeviceControlSignalsPtr SerialIoHandlerWin::GetControlSignals() const {
   DWORD status;
   if (!GetCommModemStatus(file().GetPlatformFile(), &status)) {
+    VPLOG(1) << "Failed to get port control signals";
     return serial::DeviceControlSignalsPtr();
   }
 
   serial::DeviceControlSignalsPtr signals(serial::DeviceControlSignals::New());
   signals->dcd = (status & MS_RLSD_ON) != 0;
   signals->cts = (status & MS_CTS_ON) != 0;
   signals->dsr = (status & MS_DSR_ON) != 0;
   signals->ri = (status & MS_RING_ON) != 0;
   return signals.Pass();
 }
 
 bool SerialIoHandlerWin::SetControlSignals(
     const serial::HostControlSignals& signals) {
   if (signals.has_dtr) {
     if (!EscapeCommFunction(file().GetPlatformFile(),
                             signals.dtr ? SETDTR : CLRDTR)) {
+      VPLOG(1) << "Failed to configure DTR signal";
       return false;
     }
   }
   if (signals.has_rts) {
     if (!EscapeCommFunction(file().GetPlatformFile(),
                             signals.rts ? SETRTS : CLRRTS)) {
+      VPLOG(1) << "Failed to configure RTS signal";
       return false;
     }
   }
   return true;
 }
 
 serial::ConnectionInfoPtr SerialIoHandlerWin::GetPortInfo() const {
   DCB config = {0};
   config.DCBlength = sizeof(config);
   if (!GetCommState(file().GetPlatformFile(), &config)) {
+    VPLOG(1) << "Failed to get serial port info";
     return serial::ConnectionInfoPtr();
   }
   serial::ConnectionInfoPtr info(serial::ConnectionInfo::New());
   info->bitrate = SpeedConstantToBitrate(config.BaudRate);
   info->data_bits = DataBitsConstantToEnum(config.ByteSize);
   info->parity_bit = ParityBitConstantToEnum(config.Parity);
   info->stop_bits = StopBitsConstantToEnum(config.StopBits);
   info->cts_flow_control = config.fOutxCtsFlow != 0;
   return info.Pass();
 }
 
 std::string SerialIoHandler::MaybeFixUpPortName(const std::string& port_name) {
   // For COM numbers less than 9, CreateFile is called with a string such as
   // "COM1". For numbers greater than 9, a prefix of "\\\\.\\" must be added.
   if (port_name.length() > std::string("COM9").length())
     return std::string("\\\\.\\").append(port_name);
 
   return port_name;
 }
 
 }  // namespace device