自制操作系统 - 网卡驱动

typedef struct eth_t   // 以太网帧
{
    eth_addr_t dst; // 目标地址
    eth_addr_t src; // 源地址
    u16 type;       // 类型
    u8 payload[0];  // 载荷
} _packed eth_t;

#define ETH_ADDR_LEN 6
#define IP_ADDR_LEN 4
typedef u8 eth_addr_t[ETH_ADDR_LEN]; // MAC 地址
typedef u8 ip_addr_t[IP_ADDR_LEN];   // IPV4 地址

#define RX_DESC_NR 32 // 接收描述符数量
#define TX_DESC_NR 32 // 传输描述符数量

typedef struct rx_desc_t        // 接收描述符
{
    u64 addr;     // 数据缓冲器地址
    u16 length;   // 长度
    u16 checksum; // 校验和
    u8 status;    // 状态
    u8 error;     // 错误
    u16 special;  // 特殊
} _packed rx_desc_t;

typedef struct tx_desc_t      // 传输描述符
{
    u64 addr;    // 缓冲区地址
    u16 length;  // 包长度
    u8 cso;      // Checksum Offset
    u8 cmd;      // 命令
    u8 status;   // 状态
    u8 css;      // Checksum Start Field
    u16 special; // 特殊
} _packed tx_desc_t;

#define NAME_LEN 16

typedef struct e1000_t
{
    char name[NAME_LEN]; // 名称

    pci_device_t *device; // PCI 设备
    u32 membase;          // 映射内存基地址

    u8 mac[6];   // MAC 地址
    bool link;   // 网络连接状态
    bool eeprom; // 只读存储器可用

    rx_desc_t *rx_desc; // 接收描述符
    u16 rx_cur;         // 接收描述符指针

    tx_desc_t *tx_desc; // 传输描述符
    u16 tx_cur;         // 传输描述符指针
    task_t *tx_waiter;  // 传输等待进程
} e1000_t;

static e1000_t obj;

static void recv_packet(e1000_t *e1000)   // 接收数据包
{
    while (true)
    {
        rx_desc_t *rx = &e1000->rx_desc[e1000->rx_cur];   // 接收描述符
        
        // TODO RECEIVE PACKET
        eth_t *eth = (eth_t *)(u32)(rx->addr & 0xffffffff);   // 获取以太网帧
        LOGK("ETH R [0x%04X]: %m -> %m, %d\n",
             ntohs(eth->type),
             eth->src,
             eth->dst,
             rx->length);

        rx->status = 0;
        moutl(e1000->membase + E1000_RDT, e1000->rx_cur);
        e1000->rx_cur = (e1000->rx_cur + 1) % RX_DESC_NR;
    }
}

void send_packet(eth_t *eth, u16 len)   // 发送数据包
{
    e1000_t *e1000 = &obj; 
    tx_desc_t *tx = &e1000->tx_desc[e1000->tx_cur];  // 发送描述符
    while (tx->status == 0)
    {
        assert(e1000->tx_waiter == NULL);
        e1000->tx_waiter = running_task();
        assert(task_block(e1000->tx_waiter, NULL, TASK_BLOCKED, TIMELESS) == EOK);
    }

    memcpy((void *)(u32)tx->addr, eth, len);
    tx->length = len;
    tx->cmd = TCMD_EOP | TCMD_RS | TCMD_RPS | TCMD_IFCS;
    tx->status = 0;
    e1000->tx_cur = (e1000->tx_cur + 1) % TX_DESC_NR;
    moutl(e1000->membase + E1000_TDT, e1000->tx_cur);
    LOGK("ETH S [0x%04X]: %m -> %m, %d\n",
         ntohs(eth->type),
         eth->src,
         eth->dst,
         len);
}

// 发送测试数据包
void test_e1000_send_packet()
{
    e1000_t *e1000 = &obj;    // 获取到网卡
    eth_t *eth = (eth_t *)alloc_kpage(1);   // 申请一页内存，存放以太网帧
    memcpy(eth->src, e1000->mac, 6);        // 将以太网卡的mac地址赋为源
    memcpy(eth->dst, "\xff\xff\xff\xff\xff\xff", 6);  // 将目的 MAC 设置为广播地址 FF:FF:FF:FF:FF:FF。发送到这个地址意味着局域网内所有主机都会接收到这个帧。
    eth->type = 0x0090; // LOOP 0x9000
    int len = 1500;
    memset(eth->payload, 'A', len);
    send_packet(eth, len + sizeof(eth_t));   // 发送数据包A
    free_kpage((u32)eth, 1);
}

typedef struct pbuf_t
{
    list_node_t node; // 列表节点
    size_t length;    // 载荷长度
    u32 count;        // 引用计数
    union
    {
        u8 payload[0]; // 载荷
        eth_t eth[0];  // 以太网帧
    };
} pbuf_t;

static list_t free_buf_list;
static size_t pbuf_count = 0;

pbuf_t *pbuf_get()      // 获取空闲缓冲
{
    pbuf_t *pbuf = NULL;
    if (list_empty(&free_buf_list))   // 如果链表为空就申请一页内存
    {
        u32 page = alloc_kpage(1);   
        pbuf = (pbuf_t *)page;
        list_push(&free_buf_list, &pbuf->node);

        page += PAGE_SIZE / 2;   //  一页内存分为两部分，各2048字节，加入到空闲链表
        pbuf = (pbuf_t *)page;
        list_push(&free_buf_list, &pbuf->node);

        pbuf_count += 2;
        LOGK("pbuf count %d\n", pbuf_count);
    }
    pbuf = element_entry(pbuf_t, node, list_popback(&free_buf_list));
    assert(((u32)pbuf & 0x7ff) == 0);       // 应该对齐到 2K

    pbuf->count = 1;
    return pbuf;
}

void pbuf_put(pbuf_t *pbuf)  // 释放缓冲
{
    
    assert(((u32)pbuf & 0x7ff) == 0);   // 应该对齐到 2K

    assert(pbuf->count > 0);
    pbuf->count--;
    if (pbuf->count > 0)
    {
        assert(pbuf->node.next && pbuf->node.prev);
        return;
    }

    list_push(&free_buf_list, &pbuf->node);
}

void pbuf_init()  // 初始化数据包缓冲, 即初始化链表
{
    list_init(&free_buf_list);
}