dan/Cosmos
1
0
Fork 0
mirror of https://github.com/danbulant/Cosmos synced 2026-05-19 20:39:01 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
Cosmos/source/Cosmos.HAL2/Drivers/PCI/Network/VT6102.cs

338 lines
11 KiB
C#
Raw Permalink Blame History

//using System;
//using System.Collections.Generic;
//using System.Text;
//using Cosmos.Kernel;
//namespace Cosmos.Hardware2.Network.Devices.ViaRhine
//{
// public class VT6102 : NetworkDevice
// {
// protected PCIDevice pciCard;
// protected IOAddressSpace io;
// protected MACAddress mac;
// protected List<ManagedMemorySpace> mRxBuffers;
// private ManagedMemorySpace mRxDescriptors;
// private ManagedMemorySpace mTxDescriptors;
// protected Queue<byte[]> mRecvBuffer;
// protected Queue<byte[]> mTransmitBuffer;
// private int mNextTXDesc;
// public VT6102(PCIDevice device)
// {
// if (device == null)
// {
// throw new ArgumentException("PCI Device is null. Unable to get VIA Rhine-II card");
// }
// pciCard = device;
// // We are handling this device
// pciCard.Claimed = true;
// // Setup interrupt handling
// //Interrupts.IRQ10 += HandleNetworkInterrupt;
// //Interrupts.AddIRQHandler(device.InterruptLine, HandleNetworkInterrupt);
// // Get IO Address from PCI Bus
// io = pciCard.GetAddressSpace(0) as Kernel.IOAddressSpace;
// // Enable the card
// pciCard.EnableDevice();
// // Get the EEPROM MAC Address and set it as the devices MAC
// byte[] eeprom_mac = new byte[6];
// UInt32 result = io.Read32(0x00);
// eeprom_mac[0] = BinaryHelper.GetByteFrom32bit(result, 0);
// eeprom_mac[1] = BinaryHelper.GetByteFrom32bit(result, 8);
// eeprom_mac[2] = BinaryHelper.GetByteFrom32bit(result, 16);
// eeprom_mac[3] = BinaryHelper.GetByteFrom32bit(result, 24);
// result = io.Read32(0x04);
// eeprom_mac[4] = BinaryHelper.GetByteFrom32bit(result, 0);
// eeprom_mac[5] = BinaryHelper.GetByteFrom32bit(result, 8);
// mac = new MACAddress(eeprom_mac);
// // Software Reset device
// SoftwareReset();
// // Configure Receive Config
// ReceiveConfigRegister = 0x1C;
// // Configure Transmit Config
// TransmitConfigRegister = 0x04;
// // Setup RX Descriptors
// mRxDescriptors = new ManagedMemorySpace(256, 16);
// // Setup TX Descriptors
// mTxDescriptors = new ManagedMemorySpace(256, 16);
// /* Initialize the RX and TX buffers, and set up the RX descriptors to point
// to the buffers. Also, mark the RX descriptors as being owned by the card so data
// can be received in them */
// mRxBuffers = new List<ManagedMemorySpace>();
// for (uint rxd = 0; rxd < 16; rxd++)
// {
// uint xOffset = rxd * 16;
// ManagedMemorySpace buffer = new ManagedMemorySpace(2048);
// mRxDescriptors.Write32(xOffset + 12, mRxDescriptors.Offset + xOffset + 16);
// mRxDescriptors.Write32(xOffset + 8, buffer.Offset);
// mRxDescriptors.Write32(xOffset + 4, buffer.Size);
// mRxDescriptors.Write32(xOffset, 0x80000000);
// mRxBuffers.Add(buffer);
// }
// mRxDescriptors.Write32(252, mRxDescriptors.Offset);
// for (uint txd = 0; txd < 16; txd++)
// {
// uint xOffset = txd * 16;
// mTxDescriptors.Write32(xOffset + 12, mTxDescriptors.Offset + xOffset + 16);
// mTxDescriptors.Write32(xOffset + 8, 0);
// mTxDescriptors.Write32(xOffset + 4, 0);
// mTxDescriptors.Write32(xOffset, 0);
// }
// mTxDescriptors.Write32(252, mTxDescriptors.Offset);
// mNextTXDesc = 0;
// RxDescAddressRegister = mRxDescriptors.Offset;
// TxDescAddressRegister = mTxDescriptors.Offset;
// // Setup and clear interrupts
// IntMaskRegister = 0xFFFF;
// IntStatusRegister = 0xFFFF;
// // Setup our Receive and Transmit Queues
// mTransmitBuffer = new Queue<byte[]>();
// mRecvBuffer = new Queue<byte[]>();
// }
// private void SoftwareReset()
// {
// io.Write16(0x08, 0x8000);
// while ((io.Read16(0x08) & 0x8000) != 0)
// {
// // Wait for device to reset
// }
// }
// public static void InitDriver()
// {
// Device.AddDriverInit(FindAll);
// }
// /// <summary>
// /// Retrieve all VIA Rhine-II network cards found on computer.
// /// </summary>
// /// <returns>List of all VIA Rhine-II cards</returns>
// public static void FindAll()
// {
// Console.WriteLine("Scanning for VIA Rhine-II cards...");
// foreach (PCIDevice device in Cosmos.Hardware2.PCIBus.Devices)
// {
// if ((device.VendorID == 0x1106) && (device.DeviceID == 0x3065) && (device.Claimed == false))
// {
// VT6102 nic = new VT6102(device);
// Console.WriteLine("Found VIA Rhine-II NIC on PCI " + device.Bus + ":" + device.Slot + ":" + device.Function);
// Console.WriteLine("NIC IRQ: " + device.InterruptLine);
// Console.WriteLine("NIC MAC Address: " + nic.MACAddress.ToString());
// NetworkDevice.Add(nic);
// }
// }
// }
// //protected void HandleNetworkInterrupt(ref IRQContext aContext)
// //{
// // UInt16 cur_status = IntStatusRegister;
// // if ((cur_status & 0x01) != 0)
// // {
// // ReadRawData();
// // }
// // IntStatusRegister = cur_status;
// //}
// #region Register Access
// protected UInt16 CommandRegister
// {
// get { return io.Read16(0x08); }
// set { io.Write16(0x08, value); }
// }
// protected UInt16 IntStatusRegister
// {
// get { return io.Read16(0x0C); }
// set { io.Write16(0x0C, value); }
// }
// protected UInt16 IntMaskRegister
// {
// get { return io.Read16(0x0E); }
// set { io.Write16(0x0E, value); }
// }
// protected byte ReceiveConfigRegister
// {
// get { return io.Read8(0x06); }
// set { io.Write8(0x06, value); }
// }
// protected byte TransmitConfigRegister
// {
// get { return io.Read8(0x07); }
// set { io.Write8(0x07, value); }
// }
// protected UInt32 RxDescAddressRegister
// {
// get { return io.Read32(0x18); }
// set { io.Write32(0x18, value); }
// }
// protected UInt32 TxDescAddressRegister
// {
// get { return io.Read32(0x1C); }
// set { io.Write32(0x1C, value); }
// }
// #endregion
// #region Network Device Implementation
// public override MACAddress MACAddress
// {
// get { return this.mac; }
// }
// public override bool Enable()
// {
// // Set start,rxon and txon bit on card
// CommandRegister = 0x1A;
// return base.Enable();
// }
// public override bool Ready
// {
// get { return ((CommandRegister & 0x02) != 0); }
// }
// public override bool QueueBytes(byte[] buffer, int offset, int length)
// {
// byte[] data = new byte[length];
// for (int b = 0; b < length; b++)
// {
// data[b] = buffer[b + offset];
// }
// if (SendBytes(ref data) == false)
// {
// mTransmitBuffer.Enqueue(data);
// }
// return true;
// }
// public override bool ReceiveBytes(byte[] buffer, int offset, int max)
// {
// throw new NotImplementedException();
// }
// public override byte[] ReceivePacket()
// {
// if (mRecvBuffer.Count < 1)
// {
// return null;
// }
// byte[] data = mRecvBuffer.Dequeue();
// return data;
// }
// public override int BytesAvailable()
// {
// if (mRecvBuffer.Count < 1)
// {
// return 0;
// }
// return mRecvBuffer.Peek().Length;
// }
// public override bool IsSendBufferFull()
// {
// return false;
// }
// public override bool IsReceiveBufferFull()
// {
// return false;
// }
// public override string Name
// {
// get { return "VIA Rhine-II Ethernet Adapter"; }
// }
// #endregion
// #region Helper Functions
// protected bool SendBytes(ref byte[] aData)
// {
// int txd = mNextTXDesc++;
// if (mNextTXDesc >= 16)
// {
// mNextTXDesc = 0;
// }
// uint xOffset = (uint)(txd * 16);
// UInt32 status = mTxDescriptors.Read32(xOffset);
// ManagedMemorySpace txBuffer = new ManagedMemorySpace(aData);
// if (((txBuffer.Offset % 4) != 0) || (txBuffer.Size < 64) )
// {
// txBuffer = new ManagedMemorySpace((uint)(aData.Length < 64 ? 64 : aData.Length), 4);
// for (uint b = 0; b < aData.Length; b++)
// {
// txBuffer[b] = aData[b];
// }
// }
// if ((status & 0x80000000) == 0)
// {
// mTxDescriptors.Write32(xOffset + 8, txBuffer.Offset);
// mTxDescriptors.Write32(xOffset + 4, txBuffer.Size | 0x600000 );
// mTxDescriptors.Write32(xOffset, status | 0x80000000);
// return true;
// }
// return false;
// }
// private void ReadRawData()
// {
// uint status;
// UInt16 recv_size;
// byte[] recv_data;
// for (int rxd = 0; rxd < 16; rxd++)
// {
// uint xOffset = (uint)(rxd * 16);
// status = mRxDescriptors.Read32(xOffset);
// if ((status & 0x80000000) == 0)
// {
// recv_size = (UInt16)((status & 0xFFFF0000) >> 16);
// recv_data = new byte[recv_size];
// for (uint b = 0; b < recv_size; b++)
// {
// recv_data[b] = mRxBuffers[rxd][b];
// }
// if (DataReceived != null)
// {
// DataReceived(recv_data);
// }
// else
// {
// mRecvBuffer.Enqueue(recv_data);
// }
// mRxDescriptors.Write32(xOffset, status | 0x80000000);
// }
// }
// }
// #endregion
// }
//}
Reference in a new issue View git blame Copy permalink