JaRuleEndpoint.h

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Library General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * JaRuleEndpoint.h
 * Handles the communication with a Ja Rule USB endpoint.
 * Copyright (C) 2015 Simon Newton
 */

#ifndef PLUGINS_USBDMX_JARULEENDPOINT_H_
#define PLUGINS_USBDMX_JARULEENDPOINT_H_

#include <libusb.h>
#include <ola/io/ByteString.h>
#include <ola/thread/ExecutorInterface.h>
#include <ola/thread/Mutex.h>
#include <ola/util/SequenceNumber.h>

#include <map>
#include <queue>

#include "plugins/usbdmx/LibUsbAdaptor.h"

namespace ola {
namespace plugin {
namespace usbdmx {

class JaRuleEndpoint {
 public:
  typedef enum {
    LOGS_PENDING_FLAG = 0x01,  
    FLAGS_CHANGED_FLAG = 0x02,  
    MSG_TRUNCATED_FLAG = 0x04  
  } StatusFlags;

  typedef enum {
    COMMAND_COMPLETED_OK,

     COMMAND_MALFORMED,

    COMMAND_SEND_ERROR,

    COMMAND_QUEUE_FULL,

    COMMAND_TIMEOUT,

    COMMAND_CLASS_MISMATCH,

    COMMAND_CANCELLED,
  } CommandResult;

  typedef ola::BaseCallback4<
    void, CommandResult, uint8_t, uint8_t, const ola::io::ByteString&>
      CommandCompleteCallback;

  typedef enum {
    RESET_DEVICE = 0x00,
    SET_BREAK_TIME = 0x10,
    GET_BREAK_TIME = 0x11,
    SET_MAB_TIME = 0x12,
    GET_MAB_TIME = 0x13,
    SET_RDM_BROADCAST_LISTEN = 0x20,
    GET_RDM_BROADCAST_LISTEN = 0x21,
    SET_RDM_WAIT_TIME = 0x22,
    GET_RDM_WAIT_TIME = 0x23,
    TX_DMX = 0x30,
    RDM_DUB = 0x40,
    RDM_REQUEST = 0x41,
    RDM_BROADCAST_REQUEST = 0x42,
    ECHO_COMMAND = 0xf0,
    GET_LOG = 0xf1,
    GET_FLAGS = 0xf2,
    WRITE_LOG = 0xf3,
  } CommandClass;

  JaRuleEndpoint(ola::thread::ExecutorInterface *executor,
                 AsyncronousLibUsbAdaptor *adaptor,
                 libusb_device *device);

  ~JaRuleEndpoint();

  bool Init();

  void CancelAll();

  void SendCommand(CommandClass command, const uint8_t *data, unsigned int size,
                   CommandCompleteCallback *callback);

  void _OutTransferComplete();

  void _InTransferComplete();

 private:
  // This must be a multiple of the USB packet size otherwise we can experience
  // overflows. A message can be a maximum of 640 bytes, so we'll use 1k here
  // to be safe.
  enum {
    IN_BUFFER_SIZE = 1024
  };

  enum {
    OUT_BUFFER_SIZE = 1024
  };

  // A command that is in the send queue.
  typedef struct {
    CommandClass command;
    CommandCompleteCallback *callback;
    ola::io::ByteString payload;
  } QueuedCommand;

  // A command that has been sent, and is waiting on a response.
  typedef struct {
    CommandClass command;
    CommandCompleteCallback *callback;
    // TODO(simon): we probably need a counter here to detect timeouts.
  } PendingCommand;

  // The arguments passed to the user supplied callback.
  typedef struct {
     CommandResult result;
     uint8_t return_code;
     uint8_t status_flags;
     const ola::io::ByteString payload;
  } CallbackArgs;

  typedef std::map<uint8_t, PendingCommand> PendingCommandMap;
  typedef std::queue<QueuedCommand> CommandQueue;

  ola::thread::ExecutorInterface *m_executor;
  LibUsbAdaptor *m_adaptor;
  libusb_device *m_device;
  libusb_device_handle *m_usb_handle;
  ola::SequenceNumber<uint8_t> m_token;

  ola::thread::Mutex m_mutex;
  CommandQueue m_queued_commands;  // GUARDED_BY(m_mutex);
  PendingCommandMap m_pending_commands;  // GUARDED_BY(m_mutex);

  uint8_t m_out_buffer[OUT_BUFFER_SIZE];  // GUARDED_BY(m_mutex);
  libusb_transfer *m_out_transfer;  // GUARDED_BY(m_mutex);
  bool m_out_in_progress;  // GUARDED_BY(m_mutex);

  uint8_t m_in_buffer[IN_BUFFER_SIZE];  // GUARDED_BY(m_mutex);
  libusb_transfer *m_in_transfer;  // GUARDED_BY(m_mutex);
  bool m_in_in_progress;  // GUARDED_BY(m_mutex);

  void MaybeSendCommand();  // LOCK_REQUIRED(m_mutex);
  bool SubmitInTransfer();  // LOCK_REQUIRED(m_mutex);
  void HandleResponse(const uint8_t *data,
                      unsigned int size);  // LOCK_REQUIRED(m_mutex);

  void ScheduleCallback(CommandCompleteCallback *callback,
                        CommandResult result,
                        uint8_t return_code,
                        uint8_t status_flags,
                        const ola::io::ByteString &payload);
  void RunCallback(CommandCompleteCallback *callback, CallbackArgs args);

  static const uint8_t EOF_IDENTIFIER = 0xa5;
  static const uint8_t SOF_IDENTIFIER = 0x5a;
  static const unsigned int MAX_PAYLOAD_SIZE = 513;
  static const unsigned int MIN_RESPONSE_SIZE = 9;
  static const unsigned int USB_PACKET_SIZE = 64;
  static const unsigned int MAX_IN_FLIGHT = 2;
  static const unsigned int MAX_QUEUED_MESSAGES = 10;
  static const unsigned int INTERFACE_OFFSET = 2;

  static const uint8_t IN_ENDPOINT = 0x81;
  static const uint8_t OUT_ENDPOINT = 0x01;
  static const unsigned int ENDPOINT_TIMEOUT_MS = 1000;

  DISALLOW_COPY_AND_ASSIGN(JaRuleEndpoint);
};

}  // namespace usbdmx
}  // namespace plugin
}  // namespace ola

#endif  // PLUGINS_USBDMX_JARULEENDPOINT_H_