/*
 *	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.
 */


#include "DavicomDevice.h"

#include <stdio.h>
#include <net/if_media.h>

#include "Driver.h"
#include "Settings.h"


const int kFrameSize = 1522;

enum VendorRequests {
	ReqReadRegister			= 0,
	ReqWriteRegister		= 1,
	ReqWriteRegisterByte	= 3,
};


enum DM9601Registers {
	RegNCR	= 0x00,	// Network Control Register
		NCRExtPHY	= 0x80,	// Select External PHY
		NCRFullDX	= 0x08,	// Full duplex
		NCRLoopback	= 0x06,	// Internal PHY analog loopback

	RegNSR	= 0x01,	// Network Status Register
		NSRSpeed10	= 0x80,	// 0 = 100MBps, 1 = 10MBps (internal PHY)
		NSRLinkUp	= 0x40,	// 1 = link up (internal PHY)
		NSRTXFull	= 0x10,	// TX FIFO full
		NSRRXOver	= 0x08,	// RX FIFO overflow

	RegRCR	= 0x05,	// RX Control Register
		RCRDiscardLong	= 0x20,	// Discard long packet (over 1522 bytes)
		RCRDiscardCRC	= 0x10,	// Discard CRC error packet
		RCRAllMulticast	= 0x08,	// Pass all multicast
		RCRPromiscuous	= 0x02,	// Promiscuous
		RCRRXEnable		= 0x01,	// RX enable

	RegEPCR	= 0x0b,	// EEPROM & PHY Control Register
		EPCROpSelect	= 0x08,	// EEPROM or PHY Operation Select
		EPCRRegRead		= 0x04,	// EEPROM or PHY Register Read Command
		EPCRRegWrite	= 0x02,	// EEPROM or PHY Register Write Command

	RegEPAR	= 0x0c,	// EEPROM & PHY Address Register
		EPARIntPHY		= 0x40,	// [7:6] force to 01 if Internal PHY is selected
		EPARMask		= 0x1f,	// mask [0:5]

	RegEPDRL = 0x0d, // EEPROM & PHY Low Byte Data Register

	RegEPDRH = 0x0e, // EEPROM & PHY Low Byte Data Register

	RegPAR	= 0x10,	// [0x10 - 0x15] Physical Address Register
	
	RegMAR	= 0x16,	// [0x16 - 0x1d] Multicast Address Register

	RegGPCR	= 0x1E,	// General Purpose Control Register
		GPCRPowerDown	= 0x01,	// [0:6] Define in/out direction of GPCR
								// GPIO0 - is output for Power Down function

	RegGPR	= 0x1F,	// General Purpose Register
		GPRPowerDownInPHY = 0x01,	// Power down Internal PHY

	RegUSBC	= 0xf4, // USB Control Register
		USBCIntAck		= 0x20,	// ACK with 8-bytes of data on interrupt EP
		USBCIntNAck		= 0x10,	// Supress ACK on interrupt EP

};


enum MIIRegisters {
	RegBMCR	= 0x00,
		BMCRIsolate	= 0x0400,
		BMCRReset	= 0x8000,

	RegBMSR	= 0x01,
	RegPHYID1	= 0x02,
	RegPHYID2	= 0x03,
};

#define MII_OUI(id1, id2)       (((id1) << 6) | ((id2) >> 10))
#define MII_MODEL(id2)          (((id2) & 0x03f0) >> 4)
#define MII_REV(id2)             ((id2) & 0x000f)


DavicomDevice::DavicomDevice(usb_device device, DeviceInfo& deviceInfo)
	:	fDevice(device),
		fStatus(B_ERROR),
		fOpen(false),
		fRemoved(false),
		fHasConnection(false),
		fTXBufferFull(false),
		fNonBlocking(false),
		fInsideNotify(0),
		fNotifyEndpoint(0),
		fReadEndpoint(0),
		fWriteEndpoint(0),
		fMaxTXPacketSize(0),
		fActualLengthRead(0),
		fActualLengthWrite(0),
		fStatusRead(0),
		fStatusWrite(0),
		fNotifyReadSem(-1),
		fNotifyWriteSem(-1),
		fLinkStateChangeSem(-1),
		fNotifyData(NULL)
{
	fDeviceInfo = deviceInfo;

	memset(&fMACAddress, 0, sizeof(fMACAddress));

	fNotifyReadSem = create_sem(0, DRIVER_NAME"_notify_read");
	if (fNotifyReadSem < B_OK) {
		TRACE_ALWAYS("Error of creating read notify semaphore:%#010x\n",
															fNotifyReadSem);
		return;
	}

	fNotifyWriteSem = create_sem(0, DRIVER_NAME"_notify_write");
	if (fNotifyWriteSem < B_OK) {
		TRACE_ALWAYS("Error of creating write notify semaphore:%#010x\n",
															fNotifyWriteSem);
		return;
	}

	fNotifyData = new DM9601NotifyData();
	if (fNotifyData == NULL) {
		TRACE_ALWAYS("Error allocating notify buffer\n");
		return;
	}

	if (_SetupEndpoints() != B_OK) {
		return;
	}

	_InitMII();

	fStatus = B_OK;
	TRACE("Created!\n");
}


DavicomDevice::~DavicomDevice()
{
	if (fNotifyReadSem >= B_OK)
		delete_sem(fNotifyReadSem);
	if (fNotifyWriteSem >= B_OK)
		delete_sem(fNotifyWriteSem);

	if (!fRemoved) // ???
		gUSBModule->cancel_queued_transfers(fNotifyEndpoint);

	delete fNotifyData;
	TRACE("Deleted!\n");
}


status_t
DavicomDevice::Open(uint32 flags)
{
	if (fOpen)
		return B_BUSY;
	if (fRemoved)
		return B_ERROR;

	status_t result = _StartDevice();
	if (result != B_OK) {
		return result;
	}

	// setup state notifications
	result = gUSBModule->queue_interrupt(fNotifyEndpoint, fNotifyData,
		sizeof(DM9601NotifyData), _NotifyCallback, this);
	if (result != B_OK) {
		TRACE_ALWAYS("Error of requesting notify interrupt:%#010x\n", result);
		return result;
	}

	result = _EnableInterrupts(true);

	fNonBlocking = (flags & O_NONBLOCK) == O_NONBLOCK;
	fOpen = true;
	TRACE("Opened: %#010x!\n", result);
	return result;
}


status_t
DavicomDevice::Close()
{
	if (fRemoved) {
		fOpen = false;
		return B_OK;
	}

	_EnableInterrupts(false);

	// wait until possible notification handling finished...
	while (atomic_add(&fInsideNotify, 0) != 0)
		snooze(100);
	gUSBModule->cancel_queued_transfers(fNotifyEndpoint);
	gUSBModule->cancel_queued_transfers(fReadEndpoint);
	gUSBModule->cancel_queued_transfers(fWriteEndpoint);

	fOpen = false;

	status_t result = _StopDevice();
	TRACE("Closed: %#010x!\n", result);
	return result;
}


status_t
DavicomDevice::Free()
{
	TRACE("Freed!\n");
	return B_OK;
}


status_t
DavicomDevice::Read(uint8 *buffer, size_t *numBytes)
{
	size_t numBytesToRead = *numBytes;
	*numBytes = 0;

	if (fRemoved) {
		TRACE_ALWAYS("Error of receiving %d bytes from removed device.\n",
			numBytesToRead);
		return B_DEVICE_NOT_FOUND;
	}

	TRACE_RX("Request %d bytes.\n", numBytesToRead);

	struct _RXHeader {
		uint	FOE	:1;
		uint	CE	:1;
		uint	LE	:1;
		uint	PLE	:1;
		uint	RWTO:1;
		uint	LCS	:1;
		uint	MF	:1;
		uint	RF	:1;
		uint	countLow	:8;
		uint	countHigh	:8;

		uint8	Errors() { return 0xbf & *(uint8*)this; }
	} __attribute__((__packed__));

	_RXHeader header = { 0 };

	iovec rxData[] = {
		{ &header, sizeof(header) },
		{ buffer,  numBytesToRead }
	};

	status_t result = gUSBModule->queue_bulk_v(fReadEndpoint,
		rxData, 2, _ReadCallback, this);
	if (result != B_OK) {
		TRACE_ALWAYS("Error of queue_bulk_v request:%#010x\n", result);
		return result;
	}

	uint32 flags = B_CAN_INTERRUPT | (fNonBlocking ? B_TIMEOUT : 0);
	result = acquire_sem_etc(fNotifyReadSem, 1, flags, 0);
	if (result < B_OK) {
		TRACE_ALWAYS("Error of acquiring notify semaphore:%#010x.\n", result);
		return result;
	}

	if (fStatusRead != B_OK && fStatusRead != B_CANCELED && !fRemoved) {
		TRACE_ALWAYS("Device status error:%#010x\n", fStatusRead);
		return fStatusRead;
	}

	if (fActualLengthRead < sizeof(_RXHeader)) {
		TRACE_ALWAYS("Error: no place for RXHeader: only %d of %d bytes.\n",
			fActualLengthRead, sizeof(_RXHeader));
		return B_ERROR;
	}

	if (header.Errors() != 0) {
		TRACE_ALWAYS("RX header errors %#04x detected!\n", header.Errors());
	}

	TRACE_STATS("FOE:%d CE:%d LE:%d PLE:%d rwTO:%d LCS:%d MF:%d RF:%d\n",
			header.FOE, header.CE, header.LE, header.PLE,
			header.RWTO, header.LCS, header.MF, header.RF);

	*numBytes = header.countLow | ( header.countHigh << 8 );

	if (fActualLengthRead - sizeof(_RXHeader) > *numBytes) {
		TRACE_ALWAYS("MISMATCH of the frame length: hdr %d; received:%d\n",
			*numBytes, fActualLengthRead - sizeof(_RXHeader));
	}

	TRACE_RX("Read %d bytes.\n", *numBytes);
	return B_OK;
}


status_t
DavicomDevice::Write(const uint8 *buffer, size_t *numBytes)
{
	size_t numBytesToWrite = *numBytes;
	*numBytes = 0;

	if (fRemoved) {
		TRACE_ALWAYS("Error of writing %d bytes to removed device.\n",
			numBytesToWrite);
		return B_DEVICE_NOT_FOUND;
	}

	if (!fHasConnection) {
		TRACE_ALWAYS("Error of writing %d bytes to device while down.\n",
			numBytesToWrite);
		return B_ERROR;
	}

	if (fTXBufferFull) {
		TRACE_ALWAYS("Error of writing %d bytes to device: TX buffer full.\n",
			numBytesToWrite);
		return B_ERROR;
	}

	TRACE_TX("Write %d bytes.\n", numBytesToWrite);

	// additional padding byte must be transmitted in case data size
	// to be send is multiple of pipe's max packet size
	uint16 length = numBytesToWrite;
	size_t count = 2;
	if (((numBytesToWrite + 2) % fMaxTXPacketSize) == 0) {
		length++;
		count++;
	}

	struct _TXHeader {
		uint8	countLow;
		uint8	countHigh;
	} __attribute__((__packed__));

	_TXHeader header = { (uint8)(length & 0xff),
		(uint8)((length >> 8) & 0xff) };

	uint8 padding = 0;

	iovec txData[] = {
		{ &header, sizeof(_TXHeader) },
		{ (uint8*)buffer, numBytesToWrite },
		{ &padding, 1 }
	};

	status_t result = gUSBModule->queue_bulk_v(fWriteEndpoint,
		txData, count, _WriteCallback, this);
	if (result != B_OK) {
		TRACE_ALWAYS("Error of queue_bulk_v request:%#010x\n", result);
		return result;
	}

	result = acquire_sem_etc(fNotifyWriteSem, 1, B_CAN_INTERRUPT, 0);

	if (result < B_OK) {
		TRACE_ALWAYS("Error of acquiring notify semaphore:%#010x.\n", result);
		return result;
	}

	if (fStatusWrite != B_OK && fStatusWrite != B_CANCELED && !fRemoved) {
		TRACE_ALWAYS("Device status error:%#010x\n", fStatusWrite);
		return fStatusWrite;
	}

	*numBytes = fActualLengthWrite - sizeof(_TXHeader);

	TRACE_TX("Written %d bytes.\n", *numBytes);
	return B_OK;
}


status_t
DavicomDevice::Control(uint32 op, void *buffer, size_t length)
{
	switch (op) {
		case ETHER_INIT:
			return B_OK;

		case ETHER_GETADDR:
			memcpy(buffer, &fMACAddress, sizeof(fMACAddress));
			return B_OK;

		case ETHER_GETFRAMESIZE:
			*(uint32 *)buffer = kFrameSize;
			return B_OK;

		case ETHER_NONBLOCK:
			TRACE("ETHER_NONBLOCK\n");
			fNonBlocking = *((uint8*)buffer);
			return B_OK;

		case ETHER_SETPROMISC:
			TRACE("ETHER_SETPROMISC\n");
			return _SetPromiscuousMode(*((uint8*)buffer));

		case ETHER_ADDMULTI:
			TRACE("ETHER_ADDMULTI\n");
			return _ModifyMulticastTable(true, (ether_address_t*)buffer);

		case ETHER_REMMULTI:
			TRACE("ETHER_REMMULTI\n");
			return _ModifyMulticastTable(false, (ether_address_t*)buffer);

		case ETHER_SET_LINK_STATE_SEM:
			fLinkStateChangeSem = *(sem_id *)buffer;
			return B_OK;

		case ETHER_GET_LINK_STATE:
			return _GetLinkState((ether_link_state *)buffer);

		default:
			TRACE_ALWAYS("Unhandled IOCTL catched: %#010x\n", op);
	}

	return B_DEV_INVALID_IOCTL;
}


void
DavicomDevice::Removed()
{
	fRemoved = true;
	fHasConnection = false;

	// the notify hook is different from the read and write hooks as it does
	// itself schedule traffic (while the other hooks only release a semaphore
	// to notify another thread which in turn safly checks for the removed
	// case) - so we must ensure that we are not inside the notify hook anymore
	// before returning, as we would otherwise violate the promise not to use
	// any of the pipes after returning from the removed hook
	while (atomic_add(&fInsideNotify, 0) != 0)
		snooze(100);

	gUSBModule->cancel_queued_transfers(fNotifyEndpoint);
	gUSBModule->cancel_queued_transfers(fReadEndpoint);
	gUSBModule->cancel_queued_transfers(fWriteEndpoint);

	if (fLinkStateChangeSem >= B_OK)
		release_sem_etc(fLinkStateChangeSem, 1, B_DO_NOT_RESCHEDULE);
}


status_t
DavicomDevice::SetupDevice(bool deviceReplugged)
{
	ether_address address;
	status_t result = _ReadMACAddress(&address);
	if (result != B_OK) {
		TRACE_ALWAYS("Error reading MAC address:%#010x\n", result);
		return result;
	}

	TRACE("MAC address is:%02x:%02x:%02x:%02x:%02x:%02x\n",
				address.ebyte[0], address.ebyte[1], address.ebyte[2],
				address.ebyte[3], address.ebyte[4], address.ebyte[5]);

	if (deviceReplugged) {
		// this might be the same device that was replugged - read the MAC
		// address (which should be at the same index) to make sure
		if (memcmp(&address, &fMACAddress, sizeof(address)) != 0) {
			TRACE_ALWAYS("Cannot replace device with MAC address:"
				"%02x:%02x:%02x:%02x:%02x:%02x\n",
				fMACAddress.ebyte[0], fMACAddress.ebyte[1],
				fMACAddress.ebyte[2], fMACAddress.ebyte[3],
				fMACAddress.ebyte[4], fMACAddress.ebyte[5]);
			return B_BAD_VALUE; // is not the same
		}
	} else
		fMACAddress = address;

	return B_OK;
}


status_t
DavicomDevice::CompareAndReattach(usb_device device)
{
	const usb_device_descriptor *deviceDescriptor
		= gUSBModule->get_device_descriptor(device);

	if (deviceDescriptor == NULL) {
		TRACE_ALWAYS("Error getting USB device descriptor.\n");
		return B_ERROR;
	}

	if (deviceDescriptor->vendor_id != fDeviceInfo.VendorId()
		&& deviceDescriptor->product_id != fDeviceInfo.ProductId()) {
		// this certainly isn't the same device
		return B_BAD_VALUE;
	}

	// this is the same device that was replugged - clear the removed state,
	// re-setup the endpoints and transfers and open the device if it was
	// previously opened
	fDevice = device;
	fRemoved = false;
	status_t result = _SetupEndpoints();
	if (result != B_OK) {
		fRemoved = true;
		return result;
	}

	// we need to setup hardware on device replug
	result = SetupDevice(true);
	if (result != B_OK) {
		return result;
	}

	if (fOpen) {
		fOpen = false;
		result = Open(fNonBlocking ? O_NONBLOCK : 0);
	}

	return result;
}


status_t
DavicomDevice::_SetupEndpoints()
{
	const usb_configuration_info *config
		= gUSBModule->get_nth_configuration(fDevice, 0);

	if (config == NULL) {
		TRACE_ALWAYS("Error of getting USB device configuration.\n");
		return B_ERROR;
	}

	if (config->interface_count <= 0) {
		TRACE_ALWAYS("Error:no interfaces found in USB device configuration\n");
		return B_ERROR;
	}

	usb_interface_info *interface = config->interface[0].active;
	if (interface == 0) {
		TRACE_ALWAYS("Error:invalid active interface in "
												"USB device configuration\n");
		return B_ERROR;
	}

	int notifyEndpoint = -1;
	int readEndpoint   = -1;
	int writeEndpoint  = -1;

	for (size_t ep = 0; ep < interface->endpoint_count; ep++) {
		usb_endpoint_descriptor *epd = interface->endpoint[ep].descr;
		if ((epd->attributes & USB_ENDPOINT_ATTR_MASK)
				== USB_ENDPOINT_ATTR_INTERRUPT)
		{
			notifyEndpoint = ep;
			continue;
		}

		if ((epd->attributes & USB_ENDPOINT_ATTR_MASK)
				!= USB_ENDPOINT_ATTR_BULK)
		{
			TRACE_ALWAYS("Error: USB endpoint type %#04x is unknown.\n",
					epd->attributes);
			continue;
		}

		if ((epd->endpoint_address & USB_ENDPOINT_ADDR_DIR_MASK)
				== USB_ENDPOINT_ADDR_DIR_IN)
		{
			readEndpoint = ep;
			continue;
		}

		if ((epd->endpoint_address & USB_ENDPOINT_ADDR_DIR_MASK)
				== USB_ENDPOINT_ADDR_DIR_OUT)
		{
			writeEndpoint = ep;
			continue;
		}
	}

	if (notifyEndpoint == -1 || readEndpoint == -1 || writeEndpoint == -1) {
		TRACE_ALWAYS("Error: not all USB endpoints were found: notify:%d; "
			"read:%d; write:%d\n", notifyEndpoint, readEndpoint, writeEndpoint);
		return B_ERROR;
	}

	gUSBModule->set_configuration(fDevice, config);

	fNotifyEndpoint = interface->endpoint[notifyEndpoint].handle;
	fReadEndpoint   = interface->endpoint[readEndpoint  ].handle;
	fWriteEndpoint  = interface->endpoint[writeEndpoint ].handle;
	fMaxTXPacketSize = interface->endpoint[writeEndpoint].descr->max_packet_size;

	return B_OK;
}


status_t
DavicomDevice::_ReadMACAddress(ether_address_t *address)
{
	status_t result = _ReadRegister(RegPAR,
							sizeof(ether_address), (uint8*)address);
	if (result != B_OK) {
		TRACE_ALWAYS("Error of reading MAC address:%#010x\n", result);
		return result;
	}

	return B_OK;
}


status_t
DavicomDevice::_StartDevice()
{
	uint8 control = 0;

	// disable loopback
	status_t result = _ReadRegister(RegNCR, 1, &control);
	if (result != B_OK) {
		TRACE_ALWAYS("Error reading NCR: %#010x.\n", result);
		return result;
	}

	if (control & NCRExtPHY)
		TRACE_ALWAYS("Device uses external PHY\n");

	control &= ~NCRLoopback;
	result = _Write1Register(RegNCR, control);
	if (result != B_OK) {
		TRACE_ALWAYS("Error writing %#02X to NCR: %#010x.\n", control, result);
		return result;
	}

	// Initialize RX control register, enable RX and activate multicast
	result = _ReadRegister(RegRCR, 1, &control);
	if (result != B_OK) {
		TRACE_ALWAYS("Error reading RCR: %#010x.\n", result);
		return result;
	}

	control &= ~RCRPromiscuous;
	control |= RCRDiscardLong | RCRDiscardCRC | RCRRXEnable | RCRAllMulticast;
	result = _Write1Register(RegRCR, control);
	if (result != B_OK) {
		TRACE_ALWAYS("Error writing %#02X to RCR: %#010x.\n", control, result);
		return result;
	}

	// clear POWER_DOWN state of internal PHY
	result = _ReadRegister(RegGPCR, 1, &control);
	if (result != B_OK) {
		TRACE_ALWAYS("Error reading GPCR: %#010x.\n", result);
		return result;
	}

	control |= GPCRPowerDown;
	result = _Write1Register(RegGPCR, control);
	if (result != B_OK) {
		TRACE_ALWAYS("Error writing %#02X to GPCR: %#010x.\n", control, result);
		return result;
	}

	result = _ReadRegister(RegGPR, 1, &control);
	if (result != B_OK) {
		TRACE_ALWAYS("Error reading GPR: %#010x.\n", result);
		return result;
	}

	control &= ~GPRPowerDownInPHY;
	result = _Write1Register(RegGPR, control);
	if (result != B_OK) {
		TRACE_ALWAYS("Error writing %#02X to GPR: %#010x.\n", control, result);
		return result;
	}

	return B_OK;
}


status_t
DavicomDevice::_StopDevice()
{
	uint8 control = 0;

	// disable RX
	status_t result = _ReadRegister(RegRCR, 1, &control);
	if (result != B_OK) {
		TRACE_ALWAYS("Error reading RCR: %#010x.\n", result);
		return result;
	}

	control &= ~RCRRXEnable;
	result = _Write1Register(RegRCR, control);
	if (result != B_OK)
		TRACE_ALWAYS("Error writing %#02X to RCR: %#010x.\n", control, result);

	return result;
}


status_t
DavicomDevice::_SetPromiscuousMode(bool on)
{
	uint8 control = 0;

	status_t result = _ReadRegister(RegRCR, 1, &control);
	if (result != B_OK) {
		TRACE_ALWAYS("Error reading RCR: %#010x.\n", result);
		return result;
	}

	if (on)
		control |= RCRPromiscuous;
	else
		control &= ~RCRPromiscuous;

	result = _Write1Register(RegRCR, control);
	if (result != B_OK)
		TRACE_ALWAYS("Error writing %#02X to RCR: %#010x.\n", control, result);

	return result;
}


uint32
DavicomDevice::_EthernetCRC32(const uint8* buffer, size_t length)
{
	uint32 result = 0xffffffff;
	for (size_t i = 0; i < length; i++) {
		uint8 data = *buffer++;
		for (int bit = 0; bit < 8; bit++, data >>= 1) {
			uint32 carry = ((result & 0x80000000) ? 1 : 0) ^ (data & 0x01);
			result <<= 1;
			if (carry != 0)
				result = (result ^ 0x04c11db6) | carry;
		}
	}
	return result;
}


status_t
DavicomDevice::_ModifyMulticastTable(bool join, ether_address_t *group)
{
	char groupName[6 * 3 + 1] = { 0 };
	sprintf(groupName, "%02x:%02x:%02x:%02x:%02x:%02x",
		group->ebyte[0], group->ebyte[1], group->ebyte[2],
		group->ebyte[3], group->ebyte[4], group->ebyte[5]);
	TRACE("%s multicast group %s\n", join ? "Joining" : "Leaving", groupName);

	uint32 hash = _EthernetCRC32(group->ebyte, 6);
	bool isInTable = fMulticastHashes.Find(hash) != fMulticastHashes.End();
	
	if (isInTable && join)
		return B_OK; // already listed - nothing to do

	if (!isInTable && !join) {
		TRACE_ALWAYS("Cannot leave unlisted multicast group %s!\n", groupName);
		return B_ERROR;
	}

	const size_t hashLength = 8;
	uint8 hashTable[hashLength] = { 0 };
	hashTable[hashLength - 1] |= 0x80; // broadcast address

	status_t result = _WriteRegister(RegMAR, hashLength, hashTable);
	if (result != B_OK) {
		TRACE_ALWAYS("Error initializing MAR: %#010x.\n", result);
		return result;
	}
	
	if (join)
		fMulticastHashes.PushBack(hash);
	else
		fMulticastHashes.Remove(hash);

	for (int32 i = 0; i < fMulticastHashes.Count(); i++) {
		uint32 hash = fMulticastHashes[i] >> 26;
		hashTable[hash / 8] |= 1 << (hash % 8);
	}

	// clear/set pass all multicast bit as required
	uint8 control = 0;
	result = _ReadRegister(RegRCR, 1, &control);
	if (result != B_OK) {
		TRACE_ALWAYS("Error reading RCR: %#010x.\n", result);
		return result;
	}

	if (fMulticastHashes.Count() > 0)
		control &= ~RCRAllMulticast;
	else
		control |= RCRAllMulticast;

	result = _Write1Register(RegRCR, control);
	if (result != B_OK) {
		TRACE_ALWAYS("Error writing %#02X to RCR: %#010x.\n", control, result);
		return result;
	}

	result = _WriteRegister(RegMAR, hashLength, hashTable);
	if (result != B_OK)
		TRACE_ALWAYS("Error writing hash table in MAR: %#010x.\n", result);

	return result;
}


void
DavicomDevice::_ReadCallback(void *cookie, int32 status, void *data,
	size_t actualLength)
{
	TRACE_RX("ReadCB: %d bytes; status:%#010x\n", actualLength, status);
	DavicomDevice *device = (DavicomDevice *)cookie;
	device->fActualLengthRead = actualLength;
	device->fStatusRead = status;
	device->fStats.readCount++;
	release_sem_etc(device->fNotifyReadSem, 1, B_DO_NOT_RESCHEDULE);
}


void
DavicomDevice::_WriteCallback(void *cookie, int32 status, void *data,
	size_t actualLength)
{
	TRACE_TX("WriteCB: %d bytes; status:%#010x\n", actualLength, status);
	DavicomDevice *device = (DavicomDevice *)cookie;
	device->fActualLengthWrite = actualLength;
	device->fStatusWrite = status;
	device->fStats.writeCount++;
	release_sem_etc(device->fNotifyWriteSem, 1, B_DO_NOT_RESCHEDULE);
}


void
DavicomDevice::_NotifyCallback(void *cookie, int32 status, void *data,
	size_t actualLength)
{
	DavicomDevice *device = (DavicomDevice *)cookie;
	atomic_add(&device->fInsideNotify, 1);
	if (status == B_CANCELED || device->fRemoved) {
		atomic_add(&device->fInsideNotify, -1);
		return;
	}

	if (status == B_OK)
		device->_OnNotify(actualLength);
	else
		TRACE_ALWAYS("Status error:%#010x; length:%d\n", status, actualLength);

	// schedule next notification buffer
	gUSBModule->queue_interrupt(device->fNotifyEndpoint, device->fNotifyData,
		sizeof(DM9601NotifyData), _NotifyCallback, device);
	atomic_add(&device->fInsideNotify, -1);
}


status_t
DavicomDevice::_OnNotify(uint32 actualLength)
{
	if (actualLength != sizeof(DM9601NotifyData)) {
		TRACE_ALWAYS("Data underrun error. %d of %d bytes received\n",
			actualLength, sizeof(DM9601NotifyData));
		return B_BAD_DATA;
	}

	bool linkIsUp = fNotifyData->LINKST != 0;
	fTXBufferFull = fNotifyData->TXFULL != 0;
	bool rxOverflow = fNotifyData->RXOV != 0;

	bool linkStateChange = (linkIsUp != fHasConnection);
	fHasConnection = linkIsUp;

	if (linkStateChange) {
		if (fHasConnection) {
			TRACE("Link is now up at %s Mb/s\n",
				fNotifyData->SPEED ? "10" : "100");
		} else
			TRACE("Link is now down");
	}

#ifdef UDAV_TRACE
	if (gTraceStats) {
		if (fNotifyData->TXFULL)
			fStats.txFull++;
		if (fNotifyData->RXOV)
			fStats.rxOverflow++;

		if (fNotifyData->ROC)
			fStats.rxOvCount += fNotifyData->ROC;

		if (fNotifyData->RT)
			fStats.runtFrames++;
		if (fNotifyData->LCS)
			fStats.lateRXCollisions++;
		if (fNotifyData->RWTO)
			fStats.rwTOs++;
		if (fNotifyData->PLE)
			fStats.physLayerErros++;
		if (fNotifyData->AE)
			fStats.alignmentErros++;
		if (fNotifyData->CE)
			fStats.crcErrors++;
		if (fNotifyData->FOE)
			fStats.overErrors++;

		if (fNotifyData->TSR1.LC)
			fStats.lateTXCollisions++;
		if (fNotifyData->TSR1.LCR)
			fStats.lostOfCarrier++;
		if (fNotifyData->TSR1.NC)
			fStats.noCarrier++;
		if (fNotifyData->TSR1.COL)
			fStats.txCollisions++;
		if (fNotifyData->TSR1.EC)
			fStats.excCollisions++;

		if (fNotifyData->TSR2.LC)
			fStats.lateTXCollisions++;
		if (fNotifyData->TSR2.LCR)
			fStats.lostOfCarrier++;
		if (fNotifyData->TSR2.NC)
			fStats.noCarrier++;
		if (fNotifyData->TSR2.COL)
			fStats.txCollisions++;
		if (fNotifyData->TSR2.EC)
			fStats.excCollisions++;

		fStats.notifyCount++;
	}
#endif

	if (rxOverflow)
		TRACE("RX buffer overflow. %d packets dropped\n", fNotifyData->ROC);

	uint8 tsr = 0xfc & *(uint8*)&fNotifyData->TSR1;
	if (tsr != 0)
		TRACE("TX packet 1: Status %#04x is not OK.\n", tsr);

	tsr = 0xfc & *(uint8*)&fNotifyData->TSR2;
	if (tsr != 0)
		TRACE("TX packet 2: Status %#04x is not OK.\n", tsr);

	if (linkStateChange && fLinkStateChangeSem >= B_OK)
		release_sem_etc(fLinkStateChangeSem, 1, B_DO_NOT_RESCHEDULE);
	return B_OK;
}


status_t
DavicomDevice::_GetLinkState(ether_link_state *linkState)
{
	uint8 registerValue = 0;
	status_t result = _ReadRegister(RegNSR, 1, &registerValue);
	if (result != B_OK) {
		TRACE_ALWAYS("Error reading NSR register! %x\n", result);
		return result;
	}

	if (registerValue & NSRSpeed10)
		linkState->speed = 10000000;
	else
		linkState->speed = 100000000;

	linkState->quality = 1000;

	linkState->media = IFM_ETHER | IFM_100_TX;
	if (fHasConnection) {
		linkState->media |= IFM_ACTIVE;
		result = _ReadRegister(RegNCR, 1, &registerValue);
		if (result != B_OK) {
			TRACE_ALWAYS("Error reading NCR register! %x\n", result);
			return result;
		}

		if (registerValue & NCRFullDX)
			linkState->media |= IFM_FULL_DUPLEX;
		else
			linkState->media |= IFM_HALF_DUPLEX;

		if (registerValue & NCRLoopback)
			linkState->media |= IFM_LOOP;
	}

	TRACE_STATE("Medium state: %s, %lld MBit/s, %s duplex.\n",
						(linkState->media & IFM_ACTIVE) ? "active" : "inactive",
						linkState->speed / 1000000,
						(linkState->media & IFM_FULL_DUPLEX) ? "full" : "half");

	TRACE_STATS("tx:%d rx:%d rxCn:%d rtF:%d lRxC:%d rwTO:%d PLE:%d AE:%d CE:%d "
				"oE:%d ltxC:%d lCR:%d nC:%d txC:%d exC:%d r:%d w:%d n:%d\n",
					fStats.txFull, fStats.rxOverflow, fStats.rxOvCount,
					fStats.runtFrames, fStats.lateRXCollisions, fStats.rwTOs,
					fStats.physLayerErros, fStats.alignmentErros,
					fStats.crcErrors, fStats.overErrors,
					fStats.lateTXCollisions, fStats.lostOfCarrier,
					fStats.noCarrier, fStats.txCollisions, fStats.excCollisions,
					fStats.readCount, fStats.writeCount, fStats.notifyCount);
	return B_OK;
}


status_t
DavicomDevice::_ReadRegister(uint8 reg, size_t size, uint8* buffer)
{
	if (size > 255)
		return B_BAD_VALUE;

	size_t actualLength = 0;
	status_t result = gUSBModule->send_request(fDevice,
		USB_REQTYPE_VENDOR | USB_REQTYPE_DEVICE_IN,
		ReqReadRegister, 0, reg, size, buffer, &actualLength);

	if (size != actualLength) {
		TRACE_ALWAYS("Size mismatch reading register ! asked %d got %d",
			size, actualLength);
	}

	return result;
}


status_t
DavicomDevice::_WriteRegister(uint8 reg, size_t size, uint8* buffer)
{
	if (size > 255)
		return B_BAD_VALUE;

	size_t actualLength = 0;

	status_t result = gUSBModule->send_request(fDevice,
		USB_REQTYPE_VENDOR | USB_REQTYPE_DEVICE_OUT,
		ReqWriteRegister, 0, reg, size, buffer, &actualLength);

	return result;
}


status_t
DavicomDevice::_Write1Register(uint8 reg, uint8 value)
{
	size_t actualLength = 0;

	status_t result = gUSBModule->send_request(fDevice,
		USB_REQTYPE_VENDOR | USB_REQTYPE_DEVICE_OUT,
		ReqWriteRegisterByte, value, reg, 0, NULL, &actualLength);

	return result;
}


status_t
DavicomDevice::_ReadMII(uint8 reg, uint16* data)
{
	// select PHY and set PHY register address
	status_t result = _Write1Register(RegEPAR, EPARIntPHY | (reg & EPARMask));
	if (result != B_OK) {
		TRACE_ALWAYS("Failed to set MII address %#x. Error:%#x\n", reg, result);
		return result;
	}

	// select PHY operation and initiate reading
	result = _Write1Register(RegEPCR, EPCROpSelect | EPCRRegRead);
	if (result != B_OK) {
		TRACE_ALWAYS("Failed to starting MII reading. Error:%#x\n", result);
		return result;
	}

	// finalize writing
	uint8 control = 0;
	result = _ReadRegister(RegEPCR, 1, &control);
	if (result != B_OK) {
		TRACE_ALWAYS("Failed to read EPCR register. Error:%#x\n", result);
		return result;
	}

	result = _Write1Register(RegEPCR, control & ~EPCRRegRead);
	if (result != B_OK) {
		TRACE_ALWAYS("Failed to write EPCR register. Error:%#x\n", result);
		return result;
	}

	// retrieve the result from data registers
	uint8 values[2] = { 0 };
	result = _ReadRegister(RegEPDRL, 2, values);
	if (result != B_OK) {
		TRACE_ALWAYS("Failed to retrieve data %#x. Error:%#x\n", data, result);
		return result;
	}

	*data = values[0] | values[1] << 8;
	return result;
}


status_t
DavicomDevice::_WriteMII(uint8 reg, uint16 data)
{
	// select PHY and set PHY register address
	status_t result = _Write1Register(RegEPAR, EPARIntPHY | (reg & EPARMask));
	if (result != B_OK) {
		TRACE_ALWAYS("Failed to set MII address %#x. Error:%#x\n", reg, result);
		return result;
	}

	// put the value to data register
	uint8 values[] = { (uint8)(data & 0xff), (uint8)((data >> 8) & 0xff) };
	result = _WriteRegister(RegEPDRL, sizeof(uint16), values);
	if (result != B_OK) {
		TRACE_ALWAYS("Failed to put data %#x. Error:%#x\n", data, result);
		return result;
	}

	// select PHY operation and initiate writing
	result = _Write1Register(RegEPCR, EPCROpSelect | EPCRRegWrite);
	if (result != B_OK) {
		TRACE_ALWAYS("Failed to starting MII wrintig. Error:%#x\n", result);
		return result;
	}

	// finalize writing
	uint8 control = 0;
	result = _ReadRegister(RegEPCR, 1, &control);
	if (result != B_OK) {
		TRACE_ALWAYS("Failed to read EPCR register. Error:%#x\n", result);
		return result;
	}

	result = _Write1Register(RegEPCR, control & ~EPCRRegWrite);
	if (result != B_OK)
		TRACE_ALWAYS("Failed to write EPCR register. Error:%#x\n", result);

	return result;
}


status_t
DavicomDevice::_InitMII()
{
	uint16 control = 0;
	status_t result = _ReadMII(RegBMCR, &control);
	if (result != B_OK) {
		TRACE_ALWAYS("Failed to read MII BMCR register. Error:%#x\n", result);
		return result;
	}

	result = _WriteMII(RegBMCR, control & ~BMCRIsolate);
	if (result != B_OK) {
		TRACE_ALWAYS("Failed to clear isolate PHY. Error:%#x\n", result);
		return result;
	}

	result = _WriteMII(0, BMCRReset);
	if (result != B_OK) {
		TRACE_ALWAYS("Failed to reset BMCR register. Error:%#x\n", result);
		return result;
	}

	uint16 id01 = 0, id02 = 0;
	result = _ReadMII(RegPHYID1, &id01);
	if (result != B_OK) {
		TRACE_ALWAYS("Failed to read PHY ID 0. Error:%#x\n", result);
		return result;
	}

	result = _ReadMII(RegPHYID2, &id02);
	if (result != B_OK) {
		TRACE_ALWAYS("Failed to read PHY ID 1. Error:%#x\n", result);
		return result;
	}

	TRACE_ALWAYS("MII Info: OUI:%04x; Model:%04x; rev:%02x.\n",
			MII_OUI(id01, id02), MII_MODEL(id02), MII_REV(id02));

	return result;
}


status_t
DavicomDevice::_EnableInterrupts(bool enable)
{
	uint8 control = 0;
	status_t result = _ReadRegister(RegUSBC, 1, &control);
	if (result != B_OK) {
		TRACE_ALWAYS("Error of reading USB control register:%#010x\n", result);
		return result;
	}

	if (enable) {
		control |= USBCIntAck;
		control &= ~USBCIntNAck;
	} else {
		control &= ~USBCIntAck;
	}

	result = _Write1Register(RegUSBC, control);
	if (result != B_OK)
		TRACE_ALWAYS("Error of setting USB control register:%#010x\n", result);

	return result;
}