device/serial/serial_io_handler_win.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <windows.h>
   6
   7 #include "device/serial/serial_io_handler_win.h"
   8
   9 namespace device {
  10
  11 namespace {
  12
  13 int BitrateToSpeedConstant(int bitrate) {
  14 #define BITRATE_TO_SPEED_CASE(x) \
  15   case x:                        \
  16     return CBR_##x;
  17   switch (bitrate) {
  18     BITRATE_TO_SPEED_CASE(110);
  19     BITRATE_TO_SPEED_CASE(300);
  20     BITRATE_TO_SPEED_CASE(600);
  21     BITRATE_TO_SPEED_CASE(1200);
  22     BITRATE_TO_SPEED_CASE(2400);
  23     BITRATE_TO_SPEED_CASE(4800);
  24     BITRATE_TO_SPEED_CASE(9600);
  25     BITRATE_TO_SPEED_CASE(14400);
  26     BITRATE_TO_SPEED_CASE(19200);
  27     BITRATE_TO_SPEED_CASE(38400);
  28     BITRATE_TO_SPEED_CASE(57600);
  29     BITRATE_TO_SPEED_CASE(115200);
  30     BITRATE_TO_SPEED_CASE(128000);
  31     BITRATE_TO_SPEED_CASE(256000);
  32     default:
  33       // If the bitrate doesn't match that of one of the standard
  34       // index constants, it may be provided as-is to the DCB
  35       // structure, according to MSDN.
  36       return bitrate;
  37   }
  38 #undef BITRATE_TO_SPEED_CASE
  39 }
  40
  41 int DataBitsEnumToConstant(serial::DataBits data_bits) {
  42   switch (data_bits) {
  43     case serial::DATA_BITS_SEVEN:
  44       return 7;
  45     case serial::DATA_BITS_EIGHT:
  46     default:
  47       return 8;
  48   }
  49 }
  50
  51 int ParityBitEnumToConstant(serial::ParityBit parity_bit) {
  52   switch (parity_bit) {
  53     case serial::PARITY_BIT_EVEN:
  54       return EVENPARITY;
  55     case serial::PARITY_BIT_ODD:
  56       return ODDPARITY;
  57     case serial::PARITY_BIT_NO:
  58     default:
  59       return NOPARITY;
  60   }
  61 }
  62
  63 int StopBitsEnumToConstant(serial::StopBits stop_bits) {
  64   switch (stop_bits) {
  65     case serial::STOP_BITS_TWO:
  66       return TWOSTOPBITS;
  67     case serial::STOP_BITS_ONE:
  68     default:
  69       return ONESTOPBIT;
  70   }
  71 }
  72
  73 int SpeedConstantToBitrate(int speed) {
  74 #define SPEED_TO_BITRATE_CASE(x) \
  75   case CBR_##x:                  \
  76     return x;
  77   switch (speed) {
  78     SPEED_TO_BITRATE_CASE(110);
  79     SPEED_TO_BITRATE_CASE(300);
  80     SPEED_TO_BITRATE_CASE(600);
  81     SPEED_TO_BITRATE_CASE(1200);
  82     SPEED_TO_BITRATE_CASE(2400);
  83     SPEED_TO_BITRATE_CASE(4800);
  84     SPEED_TO_BITRATE_CASE(9600);
  85     SPEED_TO_BITRATE_CASE(14400);
  86     SPEED_TO_BITRATE_CASE(19200);
  87     SPEED_TO_BITRATE_CASE(38400);
  88     SPEED_TO_BITRATE_CASE(57600);
  89     SPEED_TO_BITRATE_CASE(115200);
  90     SPEED_TO_BITRATE_CASE(128000);
  91     SPEED_TO_BITRATE_CASE(256000);
  92     default:
  93       // If it's not one of the standard index constants,
  94       // it should be an integral baud rate, according to
  95       // MSDN.
  96       return speed;
  97   }
  98 #undef SPEED_TO_BITRATE_CASE
  99 }
 100
 101 serial::DataBits DataBitsConstantToEnum(int data_bits) {
 102   switch (data_bits) {
 103     case 7:
 104       return serial::DATA_BITS_SEVEN;
 105     case 8:
 106     default:
 107       return serial::DATA_BITS_EIGHT;
 108   }
 109 }
 110
 111 serial::ParityBit ParityBitConstantToEnum(int parity_bit) {
 112   switch (parity_bit) {
 113     case EVENPARITY:
 114       return serial::PARITY_BIT_EVEN;
 115     case ODDPARITY:
 116       return serial::PARITY_BIT_ODD;
 117     case NOPARITY:
 118     default:
 119       return serial::PARITY_BIT_NO;
 120   }
 121 }
 122
 123 serial::StopBits StopBitsConstantToEnum(int stop_bits) {
 124   switch (stop_bits) {
 125     case TWOSTOPBITS:
 126       return serial::STOP_BITS_TWO;
 127     case ONESTOPBIT:
 128     default:
 129       return serial::STOP_BITS_ONE;
 130   }
 131 }
 132
 133 }  // namespace
 134
 135 // static
 136 scoped_refptr<SerialIoHandler> SerialIoHandler::Create(
 137     scoped_refptr<base::SingleThreadTaskRunner> file_thread_task_runner,
 138     scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner) {
 139   return new SerialIoHandlerWin(file_thread_task_runner, ui_thread_task_runner);
 140 }
 141
 142 bool SerialIoHandlerWin::PostOpen() {
 143   DCHECK(!comm_context_);
 144   DCHECK(!read_context_);
 145   DCHECK(!write_context_);
 146
 147   base::MessageLoopForIO::current()->RegisterIOHandler(file().GetPlatformFile(),
 148                                                        this);
 149
 150   comm_context_.reset(new base::MessageLoopForIO::IOContext());
 151   comm_context_->handler = this;
 152   memset(&comm_context_->overlapped, 0, sizeof(comm_context_->overlapped));
 153
 154   read_context_.reset(new base::MessageLoopForIO::IOContext());
 155   read_context_->handler = this;
 156   memset(&read_context_->overlapped, 0, sizeof(read_context_->overlapped));
 157
 158   write_context_.reset(new base::MessageLoopForIO::IOContext());
 159   write_context_->handler = this;
 160   memset(&write_context_->overlapped, 0, sizeof(write_context_->overlapped));
 161
 162   // A ReadIntervalTimeout of MAXDWORD will cause async reads to complete
 163   // immediately with any data that's available, even if there is none.
 164   // This is OK because we never issue a read request until WaitCommEvent
 165   // signals that data is available.
 166   COMMTIMEOUTS timeouts = {0};
 167   timeouts.ReadIntervalTimeout = MAXDWORD;
 168   if (!::SetCommTimeouts(file().GetPlatformFile(), &timeouts)) {
 169     VPLOG(1) << "Failed to set serial timeouts";
 170     return false;
 171   }
 172
 173   return true;
 174 }
 175
 176 void SerialIoHandlerWin::ReadImpl() {
 177   DCHECK(CalledOnValidThread());
 178   DCHECK(pending_read_buffer());
 179   DCHECK(file().IsValid());
 180
 181   DWORD errors;
 182   COMSTAT status;
 183   if (!ClearCommError(file().GetPlatformFile(), &errors, &status) ||
 184       errors != 0) {
 185     QueueReadCompleted(0, serial::RECEIVE_ERROR_SYSTEM_ERROR);
 186     return;
 187   }
 188
 189   if (!SetCommMask(file().GetPlatformFile(), EV_RXCHAR)) {
 190     VPLOG(1) << "Failed to set serial event flags";
 191   }
 192
 193   event_mask_ = 0;
 194   BOOL ok = ::WaitCommEvent(
 195       file().GetPlatformFile(), &event_mask_, &comm_context_->overlapped);
 196   if (!ok && GetLastError() != ERROR_IO_PENDING) {
 197     VPLOG(1) << "Failed to receive serial event";
 198     QueueReadCompleted(0, serial::RECEIVE_ERROR_SYSTEM_ERROR);
 199   }
 200   is_comm_pending_ = true;
 201 }
 202
 203 void SerialIoHandlerWin::WriteImpl() {
 204   DCHECK(CalledOnValidThread());
 205   DCHECK(pending_write_buffer());
 206   DCHECK(file().IsValid());
 207
 208   BOOL ok = ::WriteFile(file().GetPlatformFile(),
 209                         pending_write_buffer(),
 210                         pending_write_buffer_len(),
 211                         NULL,
 212                         &write_context_->overlapped);
 213   if (!ok && GetLastError() != ERROR_IO_PENDING) {
 214     QueueWriteCompleted(0, serial::SEND_ERROR_SYSTEM_ERROR);
 215   }
 216 }
 217
 218 void SerialIoHandlerWin::CancelReadImpl() {
 219   DCHECK(CalledOnValidThread());
 220   DCHECK(file().IsValid());
 221   ::CancelIo(file().GetPlatformFile());
 222 }
 223
 224 void SerialIoHandlerWin::CancelWriteImpl() {
 225   DCHECK(CalledOnValidThread());
 226   DCHECK(file().IsValid());
 227   ::CancelIo(file().GetPlatformFile());
 228 }
 229
 230 bool SerialIoHandlerWin::ConfigurePortImpl() {
 231   DCB config = {0};
 232   config.DCBlength = sizeof(config);
 233   if (!GetCommState(file().GetPlatformFile(), &config)) {
 234     VPLOG(1) << "Failed to get serial port info";
 235     return false;
 236   }
 237
 238   // Set up some sane default options that are not configurable.
 239   config.fBinary = TRUE;
 240   config.fParity = FALSE;
 241   config.fAbortOnError = TRUE;
 242   config.fOutxDsrFlow = FALSE;
 243   config.fDtrControl = DTR_CONTROL_ENABLE;
 244   config.fDsrSensitivity = FALSE;
 245   config.fOutX = FALSE;
 246   config.fInX = FALSE;
 247
 248   DCHECK(options().bitrate);
 249   config.BaudRate = BitrateToSpeedConstant(options().bitrate);
 250
 251   DCHECK(options().data_bits != serial::DATA_BITS_NONE);
 252   config.ByteSize = DataBitsEnumToConstant(options().data_bits);
 253
 254   DCHECK(options().parity_bit != serial::PARITY_BIT_NONE);
 255   config.Parity = ParityBitEnumToConstant(options().parity_bit);
 256
 257   DCHECK(options().stop_bits != serial::STOP_BITS_NONE);
 258   config.StopBits = StopBitsEnumToConstant(options().stop_bits);
 259
 260   DCHECK(options().has_cts_flow_control);
 261   if (options().cts_flow_control) {
 262     config.fOutxCtsFlow = TRUE;
 263     config.fRtsControl = RTS_CONTROL_HANDSHAKE;
 264   } else {
 265     config.fOutxCtsFlow = FALSE;
 266     config.fRtsControl = RTS_CONTROL_ENABLE;
 267   }
 268
 269   if (!SetCommState(file().GetPlatformFile(), &config)) {
 270     VPLOG(1) << "Failed to set serial port info";
 271     return false;
 272   }
 273   return true;
 274 }
 275
 276 SerialIoHandlerWin::SerialIoHandlerWin(
 277     scoped_refptr<base::SingleThreadTaskRunner> file_thread_task_runner,
 278     scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner)
 279     : SerialIoHandler(file_thread_task_runner, ui_thread_task_runner),
 280       event_mask_(0),
 281       is_comm_pending_(false) {
 282 }
 283
 284 SerialIoHandlerWin::~SerialIoHandlerWin() {
 285 }
 286
 287 void SerialIoHandlerWin::OnIOCompleted(
 288     base::MessageLoopForIO::IOContext* context,
 289     DWORD bytes_transferred,
 290     DWORD error) {
 291   DCHECK(CalledOnValidThread());
 292   if (context == comm_context_) {
 293     if (read_canceled()) {
 294       ReadCompleted(bytes_transferred, read_cancel_reason());
 295     } else if (error != ERROR_SUCCESS && error != ERROR_OPERATION_ABORTED) {
 296       ReadCompleted(0, serial::RECEIVE_ERROR_SYSTEM_ERROR);
 297     } else if (pending_read_buffer()) {
 298       BOOL ok = ::ReadFile(file().GetPlatformFile(),
 299                            pending_read_buffer(),
 300                            pending_read_buffer_len(),
 301                            NULL,
 302                            &read_context_->overlapped);
 303       if (!ok && GetLastError() != ERROR_IO_PENDING) {
 304         ReadCompleted(0, serial::RECEIVE_ERROR_SYSTEM_ERROR);
 305       }
 306     }
 307   } else if (context == read_context_) {
 308     if (read_canceled()) {
 309       ReadCompleted(bytes_transferred, read_cancel_reason());
 310     } else if (error != ERROR_SUCCESS && error != ERROR_OPERATION_ABORTED) {
 311       ReadCompleted(0, serial::RECEIVE_ERROR_SYSTEM_ERROR);
 312     } else {
 313       ReadCompleted(bytes_transferred,
 314                     error == ERROR_SUCCESS
 315                         ? serial::RECEIVE_ERROR_NONE
 316                         : serial::RECEIVE_ERROR_SYSTEM_ERROR);
 317     }
 318   } else if (context == write_context_) {
 319     DCHECK(pending_write_buffer());
 320     if (write_canceled()) {
 321       WriteCompleted(0, write_cancel_reason());
 322     } else if (error != ERROR_SUCCESS && error != ERROR_OPERATION_ABORTED) {
 323       WriteCompleted(0, serial::SEND_ERROR_SYSTEM_ERROR);
 324     } else {
 325       WriteCompleted(bytes_transferred,
 326                      error == ERROR_SUCCESS ? serial::SEND_ERROR_NONE
 327                                             : serial::SEND_ERROR_SYSTEM_ERROR);
 328     }
 329   } else {
 330     NOTREACHED() << "Invalid IOContext";
 331   }
 332 }
 333
 334 bool SerialIoHandlerWin::Flush() const {
 335   if (!PurgeComm(file().GetPlatformFile(), PURGE_RXCLEAR | PURGE_TXCLEAR)) {
 336     VPLOG(1) << "Failed to flush serial port";
 337     return false;
 338   }
 339   return true;
 340 }
 341
 342 serial::DeviceControlSignalsPtr SerialIoHandlerWin::GetControlSignals() const {
 343   DWORD status;
 344   if (!GetCommModemStatus(file().GetPlatformFile(), &status)) {
 345     VPLOG(1) << "Failed to get port control signals";
 346     return serial::DeviceControlSignalsPtr();
 347   }
 348
 349   serial::DeviceControlSignalsPtr signals(serial::DeviceControlSignals::New());
 350   signals->dcd = (status & MS_RLSD_ON) != 0;
 351   signals->cts = (status & MS_CTS_ON) != 0;
 352   signals->dsr = (status & MS_DSR_ON) != 0;
 353   signals->ri = (status & MS_RING_ON) != 0;
 354   return signals.Pass();
 355 }
 356
 357 bool SerialIoHandlerWin::SetControlSignals(
 358     const serial::HostControlSignals& signals) {
 359   if (signals.has_dtr) {
 360     if (!EscapeCommFunction(file().GetPlatformFile(),
 361                             signals.dtr ? SETDTR : CLRDTR)) {
 362       VPLOG(1) << "Failed to configure DTR signal";
 363       return false;
 364     }
 365   }
 366   if (signals.has_rts) {
 367     if (!EscapeCommFunction(file().GetPlatformFile(),
 368                             signals.rts ? SETRTS : CLRRTS)) {
 369       VPLOG(1) << "Failed to configure RTS signal";
 370       return false;
 371     }
 372   }
 373   return true;
 374 }
 375
 376 serial::ConnectionInfoPtr SerialIoHandlerWin::GetPortInfo() const {
 377   DCB config = {0};
 378   config.DCBlength = sizeof(config);
 379   if (!GetCommState(file().GetPlatformFile(), &config)) {
 380     VPLOG(1) << "Failed to get serial port info";
 381     return serial::ConnectionInfoPtr();
 382   }
 383   serial::ConnectionInfoPtr info(serial::ConnectionInfo::New());
 384   info->bitrate = SpeedConstantToBitrate(config.BaudRate);
 385   info->data_bits = DataBitsConstantToEnum(config.ByteSize);
 386   info->parity_bit = ParityBitConstantToEnum(config.Parity);
 387   info->stop_bits = StopBitsConstantToEnum(config.StopBits);
 388   info->cts_flow_control = config.fOutxCtsFlow != 0;
 389   return info.Pass();
 390 }
 391
 392 std::string SerialIoHandler::MaybeFixUpPortName(const std::string& port_name) {
 393   // For COM numbers less than 9, CreateFile is called with a string such as
 394   // "COM1". For numbers greater than 9, a prefix of "\\\\.\\" must be added.
 395   if (port_name.length() > std::string("COM9").length())
 396     return std::string("\\\\.\\").append(port_name);
 397
 398   return port_name;
 399 }
 400
 401 }  // namespace device