#include "../include/pcnet.h" #include "../include/io.h" #include "../include/description_table.h" #include "../include/pci.h" #include "../include/timer.h" #include "../include/memory.h" #include "../include/printf.h" #include "../include/dhcp.h" #include "../include/etherframe.h" #include "../include/arp.h" #include "../include/ipv4.h" #include "../include/tcp.h" #include "../include/udp.h" uint8_t bus = 255, dev = 255, func = 255; extern unsigned int PCI_ADDR_BASE; extern idt_ptr_t idt_ptr; extern uint32_t gateway, submask, dns, ip, dhcp_ip; static int io_base = 0; static uint8_t sendBufferDescMemory[2048 + 15]; static uint8_t sendBuffers[8][2048 + 15]; static uint8_t currentSendBuffer; static uint8_t recvBufferDescMemory[2048 + 15]; static uint8_t recvBuffers[8][2048 + 15]; static uint8_t currentRecvBuffer; uint8_t mac0, mac1, mac2, mac3, mac4, mac5; struct InitializationBlock initBlock; static struct BufferDescriptor* sendBufferDesc; static struct BufferDescriptor* recvBufferDesc; int recv = 0; static uint8_t* IP_Packet_Base[16] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL}; static void set_handler(int IRQ, int addr) { register_interrupt_handler(0x20 + IRQ, (int)addr); } void into_32bitsRW() { io_out16(io_base + RAP16, BCR18); uint16_t tmp = io_in16(io_base + BDP16); tmp |= 0x80; io_out16(io_base + RAP16, BCR18); io_out16(io_base + BDP16, tmp); // 此时就处于32位读写模式了 } void into_16bitsRW() { // 切换到16位读写模式 与切换到32位读写模式相反 io_out32(io_base + RAP32, BCR18); uint32_t tmp = io_in32(io_base + BDP32); tmp &= ~0x80; io_out32(io_base + RAP32, BCR18); io_out32(io_base + BDP32, tmp); } void reset_card() { // PCNET卡复位（约等于切换到16位读写模式 io_in16(io_base + RESET16); io_out16(io_base + RESET16, 0x00); // 执行完后需等待（sleep(1)） } void Activate() { // 激活PCNET IRQ中断 io_out16(io_base + RAP16, CSR0); printf("[pcnet]: io\n"); io_out16(io_base + RDP16, 0x41); printf("[pcnet]: success.\n"); io_out16(io_base + RAP16, CSR4); uint32_t temp = io_in16(io_base + RDP16); io_out16(io_base + RAP16, CSR4); io_out16(io_base + RDP16, temp | 0xc00); io_out16(io_base + RAP16, CSR0); io_out16(io_base + RDP16, 0x42); } int pcnet_find_card() { PCI_GET_DEVICE(CARD_VENDOR_ID, CARD_DEVICE_ID, &bus, &dev, &func); if (bus == 255) { return 0; } return 1; } static void init_Card_all() { currentSendBuffer = 0; currentRecvBuffer = 0; mac0 = io_in8(io_base + APROM0); mac1 = io_in8(io_base + APROM1); mac2 = io_in8(io_base + APROM2); mac3 = io_in8(io_base + APROM3); mac4 = io_in8(io_base + APROM4); mac5 = io_in8(io_base + APROM5); reset_card(); printf("SLEEP\n"); clock_sleep(1); printf("END\n"); io_out16(io_base + RAP16, BCR20); io_out16(io_base + BDP16, 0x102); io_out16(io_base + RAP16, CSR0); io_out16(io_base + RDP16, 0x0004); // 暂时停止所有传输（用于初始化PCNET网卡 initBlock.mode = 0; initBlock.reserved1numSendBuffers = (0 << 4) | 3; // 高4位是reserved1 低4位是numSendBuffers initBlock.reserved2numRecvBuffers = (0 << 4) | 3; // 高4位是reserved2 低4位是numRecvBuffers initBlock.mac0 = mac0; initBlock.mac1 = mac1; initBlock.mac2 = mac2; initBlock.mac3 = mac3; initBlock.mac4 = mac4; initBlock.mac5 = mac5; initBlock.reserved3 = 0; initBlock.logicalAddress = 0; sendBufferDesc = (struct BufferDescriptor*)(((uint32_t)&sendBufferDescMemory[0] + 15) & 0xfffffff0); initBlock.sendBufferDescAddress = (uint32_t)sendBufferDesc; recvBufferDesc = (struct BufferDescriptor*)(((uint32_t)&recvBufferDescMemory[0] + 15) & 0xfffffff0); initBlock.recvBufferDescAddress = (uint32_t)recvBufferDesc; for (uint8_t i = 0; i < 8; i++) { sendBufferDesc[i].address = (((uint32_t)&sendBuffers[i] + 15) & 0xfffffff0); sendBufferDesc[i].flags = 0xf7ff; sendBufferDesc[i].flags2 = 0; sendBufferDesc[i].avail = 0; recvBufferDesc[i].address = (((uint32_t)&recvBuffers[i] + 15) & 0xfffffff0); recvBufferDesc[i].flags = 0xf7ff | 0x80000000; recvBufferDesc[i].flags2 = 0; recvBufferDesc[i].avail = 0; memclean(recvBufferDesc[i].address, 2048); } // CSR1,CSR2赋值（initBlock地址 io_out16(io_base + RAP16, CSR1); io_out16(io_base + RDP16, (uint16_t)&initBlock); io_out16(io_base + RAP16, CSR2); io_out16(io_base + RDP16, (uint32_t)&initBlock >> 16); Activate(); initBlock.logicalAddress = 0xFFFFFFFF; ip = 0xFFFFFFFF; gateway = 0xFFFFFFFF; submask = 0xFFFFFFFF; dns = 0xFFFFFFFF; printf("DHCP DISCOVERY %08x %08x %08x %08x %08x %08x\n",&mac0,&mac1,&mac2,&mac3,&mac4,&mac5); dhcp_discovery(&mac0); while (gateway == 0xFFFFFFFF && submask == 0xFFFFFFFF && dns == 0xFFFFFFFF && ip == 0xFFFFFFFF) { initBlock.logicalAddress = ip; } } void init_pcnet_card() { printf("[\035kernel\036]: Loading pcnet driver. %x\n",pci_get_drive_irq(bus, dev, func)); register_interrupt_handler(pci_get_drive_irq(bus, dev, func) + 0x20,PCNET_IRQ); // 2,写COMMAND和STATUS寄存器 uint32_t conf = pci_read_command_status(bus, dev, func); conf &= 0xffff0000; // 保留STATUS寄存器，清除COMMAND寄存器 conf |= 0x7; // 设置第0~2位（允许PCNET网卡产生中断 pci_write_command_status(bus, dev, func, conf); io_base = pci_get_port_base(bus, dev, func); init_Card_all(); } void PCNET_IRQ(registers_t *reg) { printf("PCNET IRQ"); io_out16(io_base + RAP16, CSR0); uint16_t temp = io_in16(io_base + RDP16); if ((temp & 0x0400) == 0x0400) Recv(); io_out16(io_base + RAP16, CSR0); io_out16(io_base + RDP16, temp); // 通知PCNET网卡 中断处理完毕 if ((temp & 0x0100) == 0x0100) printf("PCNET INIT DONE\n"); io_out8(0xa0, (0x60 + pci_get_drive_irq(bus, dev, func) - 0x8)); io_out8(0x20, 0x62); return; } static uint32_t Find_IP_Packet(uint16_t ident) { for (int i = 0; i != 16; i++) { if (IP_Packet_Base[i] != NULL) { struct IPV4Message* ipv4 = (struct IPV4Message*)(IP_Packet_Base[i] + sizeof(struct EthernetFrame_head)); if (swap16(ipv4->ident) == ident) { return i; } } } return -1; } static void IP_Assembling(struct IPV4Message* ipv4, unsigned char* RawData) { uint32_t i_p = Find_IP_Packet(swap16(ipv4->ident)); struct IPV4Message* ipv4_p = (struct IPV4Message*)(IP_Packet_Base[i_p] + sizeof(struct EthernetFrame_head)); uint32_t size_p = swap16(ipv4_p->totalLength); ipv4_p->totalLength = swap16(swap16(ipv4->totalLength) + swap16(ipv4_p->totalLength) - sizeof(struct IPV4Message)); IP_Packet_Base[i_p] = (uint8_t*)realloc((void*)IP_Packet_Base[i_p], swap16(ipv4_p->totalLength)); memcpy( (void*)(IP_Packet_Base[i_p] + size_p), RawData + sizeof(struct EthernetFrame_head) + sizeof(struct IPV4Message), swap16(ipv4->totalLength) - sizeof(struct IPV4Message)); return; } void Card_Recv_Handler(unsigned char* RawData) { struct EthernetFrame_head* header = (struct EthernetFrame_head*)(RawData); if (header->type == swap16(IP_PROTOCOL)) { // IP数据报 struct IPV4Message* ipv4 = (struct IPV4Message*)(RawData + sizeof(struct EthernetFrame_head)); if (ipv4->version == 4) { if ((swap16(ipv4->flagsAndOffset) >> IP_MF) & 1) { if (Find_IP_Packet(swap16(ipv4->ident)) == -1) { for (int i = 0; i != 16; i++) { if (IP_Packet_Base[i] == NULL) { IP_Packet_Base[i] = (uint8_t*)kmalloc(swap16(ipv4->totalLength) + sizeof(struct EthernetFrame_head)); memcpy((void*)IP_Packet_Base[i], RawData, swap16(ipv4->totalLength) + sizeof(struct EthernetFrame_head)); break; } } } else { IP_Assembling(ipv4, RawData); } } else if (!((swap16(ipv4->flagsAndOffset) >> IP_MF) & 1)) { uint32_t i_p = Find_IP_Packet(swap16(ipv4->ident)); void* base = RawData; if (i_p != -1) { IP_Assembling(ipv4, RawData); base = (void*)IP_Packet_Base[i_p]; } // if (ipv4->protocol == ICMP_PROTOCOL) { // ICMP // icmp_handler(base); /*} else*/ if (ipv4->protocol == UDP_PROTOCOL) { // UDP printf("UDP\n"); udp_handler(base); } else if (ipv4->protocol == TCP_PROTOCOL) { // TCP tcp_handler(base); } if (i_p != -1) { kfree((void*)IP_Packet_Base[i_p]); IP_Packet_Base[i_p] = NULL; } } } } else if (header->type == swap16(ARP_PROTOCOL)) { // ARP arp_handler(RawData); } } void Recv() { recv = 1; printk("\nPCNET RECV: "); for (; (recvBufferDesc[currentRecvBuffer].flags & 0x80000000) == 0; currentRecvBuffer = (currentRecvBuffer + 1) % 8) { if (!(recvBufferDesc[currentRecvBuffer].flags & 0x40000000) && (recvBufferDesc[currentRecvBuffer].flags & 0x03000000) == 0x03000000) { uint32_t size = recvBufferDesc[currentRecvBuffer].flags & 0xfff; if (size > 128) size -= 4; uint8_t* buffer = (uint8_t*)(recvBufferDesc[currentRecvBuffer].address); for (int i = 0; i < (size > 128 ? 128 : size); i++) { //printk("%02x ", buffer[i]); } //printk("\n"); } recv = 0; currentRecvBuffer = 0; Card_Recv_Handler(recvBufferDesc[currentRecvBuffer].address); memclean(recvBufferDesc[currentRecvBuffer].address, 2048); recvBufferDesc[currentRecvBuffer].flags2 = 0; recvBufferDesc[currentRecvBuffer].flags = 0x8000f7ff; } currentRecvBuffer = 0; } void PcnetSend(uint8_t* buffer, int size) { while(recv); int sendDesc = currentSendBuffer; currentSendBuffer = (currentSendBuffer + 1) % 8; memclean(sendBufferDesc[currentSendBuffer].address, 2048); if (size > MTU + sizeof(struct EthernetFrame_head) + sizeof(struct EthernetFrame_tail)) size = MTU + sizeof(struct EthernetFrame_head) + sizeof(struct EthernetFrame_tail); for (uint8_t *src = buffer + size - 1, *dst = (uint8_t*)(sendBufferDesc[sendDesc].address + size - 1); src >= buffer; src--, dst--) *dst = *src; //printk("SENDING: "); for (int i = 0; i < (size > 128 ? 128 : size); i++) { //printk("%02x ", buffer[i]); } //printk("\n"); sendBufferDesc[sendDesc].avail = 0; sendBufferDesc[sendDesc].flags = 0x8300f000 | ((uint16_t)((-size) & 0xfff)); sendBufferDesc[sendDesc].flags2 = 0; io_out16(io_base + RAP16, CSR0); io_out16(io_base + RDP16, 0x48); currentSendBuffer = 0; }