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_