Dm9601.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef DM9601_H
#define DM9601_H
 
#include "pedigree/kernel/Atomic.h"
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/machine/Network.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/process/OperationBarrier.h"
#include "pedigree/kernel/process/OwnedThread.h"
#include "pedigree/kernel/process/Semaphore.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/new"
 
#include "modules/system/usb/UsbDevice.h"
 
class Dm9601 : public UsbDevice, public Network {
 public:
  Dm9601(UsbDevice* pDev);
 
  virtual ~Dm9601();
 
  virtual void initialiseDriver();
 
  virtual void getName(String& str) {
    str.assign("DM9601", 7);
  }
 
  virtual bool send(size_t nBytes, uintptr_t buffer);
 
  virtual bool setStationInfo(const StationInfo& info);
 
  virtual const StationInfo& getStationInfo();
 
 private:
  static int recvTrampoline(void* p);
 
  static int trampoline(void* p);
 
  void receiveThread();
 
  void receiveLoop();
 
  void doReceive();
 
  enum VendorRequests {
    ReadRegister = 0,
    WriteRegister = 1,
    ReadMemory = 2,
    WriteRegister1 = 3,
    WriteMemory = 5,
    WriteMemory1 = 7,
  };
 
  enum Registers {
    NetworkControl = 0,
    NetworkStatus = 1,
    TxControl = 2,
    TxStatus1 = 3,
    TxStatus2 = 4,
    RxControl = 5,
    RxStatus = 6,
    RxOverflowCount = 7,
    BackPressThreshold = 8,
    FlowControl = 9,
    RxFlowControl = 10,
    PhyControl = 11,
    PhyAddress = 12,
    PhyLowByte = 13,
    PhyHighByte = 14,
    WakeUpControl = 15,
    PhysicalAddress = 16,
    MulticastAddress = 22,
    GeneralPurposeCtl = 30,
    GeneralPurpose = 31,
    TxWriteAddressLo = 32,
    TxWriteAddressHi = 33,
    TxReadAddressLo = 34,
    TxReadAddressHi = 35,
    RxWriteAddressLo = 36,
    RxWriteAddressHi = 37,
    RxReadAddressLo = 38,
    RxReadAddressHi = 39,
    Vendor = 40,
    Product = 42,
    Chip = 44,
 
    UsbAddress = 0xF0,
    RxCounter = 0xF1,
    TxCount = 0xF2,
    UsbStatus = 0xF2,
    UsbControl = 0xF4
  };
 
  struct InterruptInPacket {
    uint8_t networkStatus;
    uint8_t txStatus1;
    uint8_t txStatus2;
    uint8_t rxStatus;
    uint8_t rxOverflowCounter;
    uint8_t rxCounter;
    uint8_t txCounter;
    uint8_t gpRegister;
  } PACKED;
 
  bool readRegister(uint8_t reg, uintptr_t buffer, size_t nBytes);
 
  bool writeRegister(uint8_t reg, uintptr_t buffer, size_t nBytes);
 
  bool writeRegister(uint8_t reg, uint8_t data);
 
  bool readMemory(uint16_t offset, uintptr_t buffer, size_t nBytes);
 
  bool writeMemory(uint16_t offset, uintptr_t buffer, size_t nBytes);
 
  bool writeMemory(uint16_t offset, uint8_t data);
 
  bool readEeprom(uint8_t offset, uint16_t& value);
 
  bool writeEeprom(uint8_t offset, uint16_t data);
 
  bool readMii(uint8_t offset, uint16_t& value);
 
  bool writeMii(uint8_t offset, uint16_t data);
 
  bool readSharedWord(bool phy, uint8_t offset, uint16_t& value);
  bool writeSharedWord(bool phy, uint8_t offset, uint16_t value);
  bool waitForSharedOperation();
  bool resetDevice();
  bool waitForLink();
  bool waitForTxReady();
 
  Endpoint* m_pInEndpoint;
 
  Endpoint* m_pOutEndpoint;
 
  Mutex m_TxLock;
 
  Mutex m_SharedRegisterLock;
 
  Semaphore m_IncomingPackets;
 
  struct Packet {
    uintptr_t buffer;
    size_t len;
    uint32_t offset;
    Packet* next;
  };
  Packet* m_RxQueueHead;
  Packet* m_RxQueueTail;
  Spinlock m_RxPacketQueueLock;
 
  size_t m_TxPacket;
 
  Atomic<bool> m_Running;
  bool m_Registered;
  OperationBarrier m_Operations;
  OwnedThread m_PacketWorker;
  OwnedThread m_ReceiveWorker;
 
  Dm9601(const Dm9601&);
  void operator=(const Dm9601&);
};
 
#endif