/*
 *      Davicom DM9601 USB 1.1 Ethernet Driver.
 *      Copyright (c) 2008, 2011 Siarzhuk Zharski <imker@gmx.li>
 *      Copyright (c) 2009 Adrien Destugues <pulkomandy@gmail.com>
 *      Distributed under the terms of the MIT license.
 *
 *      Heavily based on code of the
 *      Driver for USB Ethernet Control Model devices
 *      Copyright (C) 2008 Michael Lotz <mmlr@mlotz.ch>
 *      Distributed under the terms of the MIT license.
 */
#ifndef _USB_DAVICOM_DEVICE_H_
#define _USB_DAVICOM_DEVICE_H_


#include <ether_driver.h>
#include <util/Vector.h>

#include "Driver.h"


struct DM9601NotifyData {
        // Network Status Register
        uint RXRDY      :1;
        uint RXOV       :1;
        uint TX1END     :1;
        uint TX2END     :1;
        uint TXFULL     :1;
        uint WAKEST     :1;
        uint LINKST     :1;
        uint SPEED      :1;

        struct {
                uint            :2;
                uint EC         :1;
                uint COL        :1;
                uint LC         :1;
                uint NC         :1;
                uint LCR        :1;
                uint            :1;
        } __attribute__((__packed__)) TSR1, TSR2;

        // RX Status Register
        uint FOE        :1;
        uint CE         :1;
        uint AE         :1;
        uint PLE        :1;
        uint RWTO       :1;
        uint LCS        :1;
        uint MF         :1;
        uint RT         :1;

        // RX Overflows Count
        uint RXFU       :1;
        uint ROC        :7;

        uint RXC        :8;
        uint TXC        :8;
        uint GPR        :8;

        DM9601NotifyData() { memset(this, 0, sizeof(DM9601NotifyData)); }
} __attribute__((__packed__));


struct DeviceInfo {
        uint16  fIds[2];

        const char* fName;
        inline uint16           VendorId()      { return fIds[0]; }
        inline uint16           ProductId()     { return fIds[1]; }
        inline uint32           Key()           { return fIds[0] << 16 | fIds[1]; }
};

class DavicomDevice {

                struct _Statistics {
                        // NSR
                        int txFull;
                        int rxOverflow;
                        int rxOvCount;
                        // RSR
                        int     runtFrames;
                        int lateRXCollisions;
                        int rwTOs;
                        int physLayerErros;
                        int alignmentErros;
                        int crcErrors;
                        int overErrors;
                        // TSR 1/2
                        int lateTXCollisions;
                        int lostOfCarrier;
                        int noCarrier;
                        int txCollisions;
                        int excCollisions;

                        int notifyCount;
                        int readCount;
                        int writeCount;
                        _Statistics() { memset(this, 0, sizeof(_Statistics)); }
                };

public:
                                                        DavicomDevice(usb_device device, DeviceInfo& Info);
                                                        ~DavicomDevice();

                status_t                        InitCheck() { return fStatus; };

                status_t                        Open(uint32 flags);
                bool                            IsOpen() { return fOpen; };

                status_t                        Close();
                status_t                        Free();

                status_t                        Read(uint8 *buffer, size_t *numBytes);
                status_t                        Write(const uint8 *buffer, size_t *numBytes);
                status_t                        Control(uint32 op, void *buffer, size_t length);

                void                            Removed();
                bool                            IsRemoved() { return fRemoved; };

                status_t                        CompareAndReattach(usb_device device);
                status_t                        SetupDevice(bool deviceReplugged);

private:
static  void                            _ReadCallback(void *cookie, int32 status,
                                                                void *data, size_t actualLength);
static  void                            _WriteCallback(void *cookie, int32 status,
                                                                void *data, size_t actualLength);
static  void                            _NotifyCallback(void *cookie, int32 status,
                                                                void *data, size_t actualLength);

                status_t                        _SetupEndpoints();

                status_t                        _StartDevice();
                status_t                        _StopDevice();
                status_t                        _OnNotify(uint32 actualLength);
                status_t                        _GetLinkState(ether_link_state *state);
                status_t                        _SetPromiscuousMode(bool bOn);
                uint32                          _EthernetCRC32(const uint8* buffer, size_t length);
                status_t                        _ModifyMulticastTable(bool join,
                                                                ether_address_t *group);
                status_t                        _ReadMACAddress(ether_address_t *address);

                status_t                        _ReadRegister(uint8 reg, size_t size, uint8* buffer);
                status_t                        _WriteRegister(uint8 reg, size_t size, uint8* buffer);
                status_t                        _Write1Register(uint8 reg, uint8 buffer);
                status_t                        _ReadMII(uint8 reg, uint16* data);
                status_t                        _WriteMII(uint8 reg, uint16 data);
                status_t                        _InitMII();
                status_t                        _EnableInterrupts(bool enable);


                // device info
                usb_device                      fDevice;
                DeviceInfo                      fDeviceInfo;
                ether_address_t         fMACAddress;

                // state tracking
                status_t                        fStatus;
                bool                            fOpen;
                bool                            fRemoved;
                bool                            fHasConnection;
                bool                            fTXBufferFull;
                bool                            fNonBlocking;
                int32                           fInsideNotify;

                // pipes for notifications, data io and tx packet size
                usb_pipe                        fNotifyEndpoint;
                usb_pipe                        fReadEndpoint;
                usb_pipe                        fWriteEndpoint;
                uint16                          fMaxTXPacketSize;

                // data stores for async usb transfers
                uint32                          fActualLengthRead;
                uint32                          fActualLengthWrite;
                int32                           fStatusRead;
                int32                           fStatusWrite;
                sem_id                          fNotifyReadSem;
                sem_id                          fNotifyWriteSem;
                sem_id                          fLinkStateChangeSem;

                DM9601NotifyData*       fNotifyData;
                _Statistics                     fStats;
                Vector<uint32>          fMulticastHashes;
};

#endif // _USB_DAVICOM_DEVICE_H_