/*
 * Copyright (c) 2007-2008 by Michael Lotz
 * Heavily based on the original usb_serial driver which is:
 *
 * Copyright (c) 2003 by Siarzhuk Zharski <imker@gmx.li>
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Alexander von Gluck IV, kallisti5@unixzen.com
 */
#ifndef _USB_DEVICE_H_
#define _USB_DEVICE_H_


#include "Driver.h"


struct usb_serial_device {
        uint32      vendorID;
        uint32      productID;
        const char* deviceName;
};


class SerialDevice {
public:
                                                                SerialDevice(usb_device device,
                                                                        uint16 vendorID, uint16 productID,
                                                                        const char *description);
virtual                                                 ~SerialDevice();

static  SerialDevice *                  MakeDevice(usb_device device, uint16 vendorID,
                                                                        uint16 productID);

                status_t                                Init();

                usb_device                              Device() { return fDevice; };
                uint16                                  ProductID() { return fProductID; };
                uint16                                  VendorID() { return fVendorID; };
                const char *                    Description() { return fDescription; };

                void                                    SetControlPipe(usb_pipe handle);
                usb_pipe                                ControlPipe() { return fControlPipe; };

                void                                    SetReadPipe(usb_pipe handle);
                usb_pipe                                ReadPipe() { return fReadPipe; };

                void                                    SetWritePipe(usb_pipe handle);
                usb_pipe                                WritePipe() { return fWritePipe; }

                char *                                  ReadBuffer() { return fReadBuffer; };
                size_t                                  ReadBufferSize() { return fReadBufferSize; };

                char *                                  WriteBuffer() { return fWriteBuffer; };
                size_t                                  WriteBufferSize() { return fWriteBufferSize; };

                void                                    SetModes(struct termios *tios);
                bool                                    Service(struct tty *tty, uint32 op,
                                                                        void *buffer, size_t length);

                status_t                                Open(uint32 flags);
                status_t                                Read(char *buffer, size_t *numBytes);
                status_t                                Write(const char *buffer, size_t *numBytes);
                status_t                                Control(uint32 op, void *arg, size_t length);
                status_t                                Select(uint8 event, uint32 ref, selectsync *sync);
                status_t                                DeSelect(uint8 event, selectsync *sync);
                status_t                                Close();
                status_t                                Free();

                bool                                    IsOpen() { return fDeviceOpen; };
                void                                    Removed();
                bool                                    IsRemoved() { return fDeviceRemoved; };

                /* virtual interface to be overriden as necessary */
virtual status_t                                AddDevice(const usb_configuration_info *config);

virtual status_t                                ResetDevice();

virtual status_t                                SetLineCoding(usb_cdc_line_coding *coding);
virtual status_t                                SetControlLineState(uint16 state);
virtual status_t                                SetHardwareFlowControl(bool enable);

virtual void                                    OnRead(char **buffer, size_t *numBytes);
virtual void                                    OnWrite(const char *buffer, size_t *numBytes,
                                                                        size_t *packetBytes);
virtual void                                    OnClose();

protected:
                void                                    SetReadBufferSize(size_t size) { fReadBufferSize = size; };
                void                                    SetWriteBufferSize(size_t size) { fWriteBufferSize = size; };
                void                                    SetInterruptBufferSize(size_t size) { fInterruptBufferSize = size; };

private:
static  int32                                   _InputThread(void *data);
                status_t                                _WriteToDevice();

static  void                                    _ReadCallbackFunction(void *cookie,
                                                                        int32 status, void *data,
                                                                        size_t actualLength);
static  void                                    _WriteCallbackFunction(void *cookie,
                                                                        int32 status, void *data,
                                                                        size_t actualLength);
static  void                                    _InterruptCallbackFunction(void *cookie,
                                                                        int32 status, void *data,
                                                                        size_t actualLength);

                usb_device                              fDevice;                // USB device handle
                uint16                                  fVendorID;
                uint16                                  fProductID;
                const char *                    fDescription;   // informational description
                bool                                    fDeviceOpen;
                bool                                    fDeviceRemoved;

                /* communication pipes */
                usb_pipe                                fControlPipe;
                usb_pipe                                fReadPipe;
                usb_pipe                                fWritePipe;

                /* line coding */
                usb_cdc_line_coding             fLineCoding;

                /* data buffers */
                area_id                                 fBufferArea;
                char *                                  fReadBuffer;
                size_t                                  fReadBufferSize;
                char *                                  fOutputBuffer;
                size_t                                  fOutputBufferSize;
                char *                                  fWriteBuffer;
                size_t                                  fWriteBufferSize;
                char *                                  fInterruptBuffer;
                size_t                                  fInterruptBufferSize;

                /* variables used in callback functionality */
                size_t                                  fActualLengthRead;
                status_t                                fStatusRead;
                size_t                                  fActualLengthWrite;
                status_t                                fStatusWrite;
                size_t                                  fActualLengthInterrupt;
                status_t                                fStatusInterrupt;

                /* semaphores used in callbacks */
                sem_id                                  fDoneRead;
                sem_id                                  fDoneWrite;

                uint16                                  fControlOut;
                bool                                    fInputStopped;
                struct tty *                    fMasterTTY;
                struct tty *                    fSlaveTTY;
                struct tty_cookie *             fSystemTTYCookie;
                struct tty_cookie *             fDeviceTTYCookie;
                struct termios                  fTTYConfig;

                /* input thread management */
                thread_id                               fInputThread;
                bool                                    fStopThreads;
};

#endif // _USB_DEVICE_H_