ethernet.cx

//-*-C-*-
/*******************************************************************************
*   ___   public
*  ¦OUX¦  C+
*  ¦/C+¦  OUX/C+ OS
*   ---   kernel
*         Ethernet driver for Intel 82545EM
* (c)overcq              on WSL\Debian (Linux 6.6.87.2)               2026-2-8 W
*******************************************************************************/
#define E_ethernet_S_receive_buffer_size    ( 16 * 1024 )
//==============================================================================
struct E_net_Z_interface;
struct __attribute__ (( __packed__ )) E_ethernet_Z_receive_descriptor
{ N64 buffer_address;
  N16 length;
  N16 packet_checksum;
  N8 dd         :1;
  N8 eop        :1;
  N8 ixsm       :1;
  N8 vp         :1;
  N8 reserved_0 :1;
  N8 tcpcs      :1;
  N8 ipcs       :1;
  N8 pif        :1;
  N8 ce         :1;
  N8 se         :1;
  N8 seq        :1;
  N8 reserved_1 :1;
  N8 cxe        :1;
  N8 tcpe       :1;
  N8 ipe        :1;
  N8 rxe        :1;
  N16 vlan      :12;
  N16 cfi       :1;
  N16 pri       :3;
};
struct __attribute__ (( __packed__ )) E_ethernet_Z_transmit_descriptor
{ N64 buffer_address;
  N16 length;
  N8 cso;
  N8 eop        :1;
  N8 ifcs       :1;
  N8 tse        :1;
  N8 rs         :1;
  N8 rps        :1;
  N8 dext       :1;
  N8 vle        :1;
  N8 ide        :1;
  N8 dd         :1;
  N8 reserved_0 :7;
  N8 css;
  N16 special;
};
struct __attribute__ (( __packed__ )) E_ethernet_Z_tcpip_context_descriptor
{ N8 ipcss;
  N8 ipcso;
  N16 ipcse;
  N8 tucss;
  N8 tucso;
  N16 tucse;
  N32 paylen    :20;
  N32 dtyp      :4;
  N32 tcp       :1;
  N32 ip        :1;
  N32 tse       :1;
  N32 rs        :1;
  N32 reserved_0:1;
  N32 dext      :1;
  N32 reserved_1:1;
  N32 ide       :1;
  N8 dd         :1;
  N8 reserved_2 :7;
  N8 hdrlen;
  N16 mss;
};
struct __attribute__ (( __packed__ )) E_ethernet_Z_tcpip_data_descriptor
{ N64 buffer_address;
  N32 dtalen    :20;
  N32 dtyp      :4;
  N32 eop       :1;
  N32 ifcs      :1;
  N32 tse       :1;
  N32 rs        :1;
  N32 rps       :1;
  N32 dext      :1;
  N32 vle       :1;
  N32 ide       :1;
  N8 dd         :1;
  N8 reserved_0 :7;
  N8 ixsm       :1;
  N8 txsm       :1;
  N8 reserved_1 :6;
  N16 vlan      :12;
  N16 cfi       :1;
  N16 pri       :3;
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
struct E_ethernet_Z_transmit_queue
{ P buffer;
  N buffer_l;
};
//==============================================================================
_private struct E_ethernet_Z_transmit_queue *E_ethernet_S_transmit_queue;
_private N E_ethernet_S_transmit_queue_n;
//==============================================================================
_private
void
E_ethernet_I_interrupt( void
){  N32 sched_i = E_flow_I_current_scheduler();
    U_F( E_flow_S_scheduler[ sched_i ].state, inside_interrupt );
    G( "Ethernet interrupt" );
    for_each( interface_id, E_net_S_interface, E_mem_Q_tab )
    {   struct E_net_Z_interface *interface = E_mem_Q_tab_R( E_net_S_interface, interface_id );
        N32 cause = *( N32 * )(( Pc )interface->register_memory + 0xc0 );
        G( "cause=%32x", cause );
        if( cause & ( 1 << 2 ))
        {   G( "link status change" );
        }
        if(( cause & ( 1 << 0 ))
        && E_ethernet_S_transmit_queue_n
        )
        {   N32 queue_i = 0;
            N32 count = *( N32 * )(( Pc )interface->register_memory + 0x3808 ) / sizeof( struct E_ethernet_Z_transmit_descriptor );
            N32 head = *( N32 * )(( Pc )interface->register_memory + 0x3810 ) % count;
            N32 tail = *( N32 * )(( Pc )interface->register_memory + 0x3818 );
            struct E_ethernet_Z_transmit_descriptor *transmit_descriptors = E_main_Z_p_I_to_virtual( (P)*( N64 * )(( Pc )interface->register_memory + 0x3800 ));
            B eop = yes;
            do
            {   N part_count = E_ethernet_S_transmit_queue[ queue_i ].buffer_l / E_ethernet_S_receive_buffer_size + ( E_ethernet_S_transmit_queue[ queue_i ].buffer_l % E_ethernet_S_receive_buffer_size ? 1 : 0 );
                if(( tail < head
                && part_count > head - 1 - tail
                )
                || ( tail > head
                && part_count > count - 1 - tail + head
                ))
                    break;
                N last;
                for_n( i, part_count )
                {   if(eop)
                        if( W( E_main_Z_p_I_to_virtual( (P)transmit_descriptors[tail].buffer_address )))
                            E_main_I_error_fatal();
                    eop = transmit_descriptors[tail].eop;
                    _0_( &transmit_descriptors[tail] );
                    transmit_descriptors[tail].buffer_address = ( N64 )E_main_Z_p_I_to_physical( E_ethernet_S_transmit_queue[ queue_i ].buffer ) + i * E_ethernet_S_receive_buffer_size;
                    transmit_descriptors[tail].length = E_ethernet_S_receive_buffer_size;
                    transmit_descriptors[tail].rs = 1;
                    last = tail;
                    tail = ( tail + 1 ) % count;
                }
                transmit_descriptors[last].length = E_ethernet_S_transmit_queue[ queue_i ].buffer_l % E_ethernet_S_receive_buffer_size;
                transmit_descriptors[last].ifcs = 1;
                transmit_descriptors[last].eop = 1;
                queue_i++;
            }while( --E_ethernet_S_transmit_queue_n );
            if( queue_i )
            {   if( !E_mem_Q_blk_I_remove( &E_ethernet_S_transmit_queue, 0, queue_i ))
                    E_main_I_error_fatal();
                *( N32 * )(( Pc )interface->register_memory + 0x3818 ) = tail;
            }
        }
        if( cause & (( 1 << 4 ) | ( 1 << 7 )))
        {   G( "received" );
            struct E_ethernet_Z_receive_descriptor *receive_descriptors = E_main_Z_p_I_to_virtual( (P)*( N64 * )(( Pc )interface->register_memory + 0x2800 ));
            N32 count = *( N32 * )(( Pc )interface->register_memory + 0x2808 ) / sizeof( struct E_ethernet_Z_receive_descriptor );
            N32 head = *( N32 * )(( Pc )interface->register_memory + 0x2810 ) % count;
            N32 tail = ( *( N32 * )(( Pc )interface->register_memory + 0x2818 ) + 1 ) % count;
            G( "count=%32x,head=%32x,tail=%32x", count, head, tail );
            if( receive_descriptors[tail].dd )
            {   do
                {   G( "dd %x", tail );
                    receive_descriptors[tail].dd = no;
                    struct E_net_Z_ethernet_header *eth = E_main_Z_p_I_to_virtual( (P)receive_descriptors[tail].buffer_address );
                    struct E_net_Z_ipv4_header *ipv4 = (P)(( Pc )eth + sizeof( struct E_net_Z_ethernet_header ));
                    if( ipv4->version == 4 )
                    {   if( E_net_I_checksum( (P)ipv4, (P)(( Pc )ipv4 + sizeof( struct E_net_Z_ipv4_header ))) != 0xffff )
                            break;
                        switch( ipv4->protocol )
                        { case 1: // ICMP
                                G( "ICMP" );
                                break;
                        case 6: // TCP
                                G( "TCP" );
                                break;
                        case 17: // UDP
                            {   G( "UDP" );
                                struct E_net_Z_udp_header *udp4 = (P)(( Pc )ipv4 + sizeof( struct E_net_Z_ipv4_header ));
                                if( udp4->length < 8 )
                                    break;
                                for_each( connection_id, E_net_S_udp4_connection_state, E_mem_Q_tab )
                                {   struct E_net_Z_udp4_connection_state *connection_state = E_mem_Q_tab_R( E_net_S_udp4_connection_state, connection_id );
                                    G( "local_address=%32x,remote_address=%32x,local_port=%16x,remote_port=%16x", connection_state->ip4.local_address, connection_state->ip4.remote_address, connection_state->local_port, connection_state->remote_port );
                                    G( "destination_address=%32x,source_address=%32x,destination_port=%16x,source_port=%16x", ipv4->destination_address, ipv4->source_address, udp4->destination_port, udp4->source_port );
                                    if(( !connection_state->ip4.local_address
                                    || connection_state->ip4.local_address == ipv4->destination_address
                                    )
                                    && ( connection_state->ip4.remote_address == 0xffffffff
                                    || connection_state->ip4.remote_address == ipv4->source_address
                                    )
                                    && connection_state->local_port == udp4->destination_port
                                    && connection_state->remote_port == udp4->source_port
                                    )
                                    {   G( "found connection" );
                                        if( connection_state->buffer )
                                        {   while( !receive_descriptors[tail].eop )
                                            {   tail = ( tail + 1 ) % count;
                                                if( tail == head )
                                                    E_main_I_error_fatal();
                                                receive_descriptors[tail].dd = no;
                                            }
                                            break;
                                        }
                                        N length = sizeof( struct E_net_Z_ethernet_header ) + sizeof( struct E_net_Z_ipv4_header ) + udp4->length;
                                        connection_state->buffer = M(length);
                                        if( !connection_state->buffer )
                                            E_main_I_error_fatal();
                                        N offset = J_min( length, E_ethernet_S_receive_buffer_size );
                                        E_mem_Q_blk_I_copy( connection_state->buffer, ( Pc )eth, offset );
                                        length -= offset;
                                        if( !receive_descriptors[tail].eop )
                                        {   do
                                            {   tail = ( tail + 1 ) % count;
                                                if( tail == head
                                                || length <= E_ethernet_S_receive_buffer_size
                                                )
                                                    E_main_I_error_fatal();
                                                E_mem_Q_blk_I_copy( connection_state->buffer + offset, E_main_Z_p_I_to_virtual( (P)receive_descriptors[tail].buffer_address ), E_ethernet_S_receive_buffer_size );
                                                offset += E_ethernet_S_receive_buffer_size;
                                                length -= E_ethernet_S_receive_buffer_size;
                                            }while( !receive_descriptors[tail].eop );
                                            tail = ( tail + 1 ) % count;
                                            if( tail == head )
                                                E_main_I_error_fatal();
                                            E_mem_Q_blk_I_copy( connection_state->buffer + offset, E_main_Z_p_I_to_virtual( (P)receive_descriptors[tail].buffer_address ), length );
                                        }
                                        struct E_net_Z_ethernet_header *eth = (P)connection_state->buffer;
                                        struct E_net_Z_ipv4_header *ipv4 = (P)(( Pc )eth + sizeof( struct E_net_Z_ethernet_header ));
                                        struct E_net_Z_udp_header *udp4 = (P)(( Pc )ipv4 + sizeof( struct E_net_Z_ipv4_header ));
                                        if( udp4->checksum )
                                        {   struct E_net_Z_ipv4_header_checksum ipv4_checksum =
                                            { ipv4->source_address
                                            , ipv4->destination_address
                                            , 0
                                            , ipv4->protocol
                                            , udp4->length
                                            };
                                            N16 checksum = 0, carry = 0;
                                            E_net_I_checksum_0( (P)&ipv4_checksum, (P)(( Pc )&ipv4_checksum + sizeof( ipv4_checksum )), &checksum, &carry );
                                            E_net_I_checksum_0( (P)udp4, (P)(( Pc )udp4 + udp4->length ), &checksum, &carry );
                                            E_net_I_checksum_1( &checksum, &carry );
                                            if( checksum != 0xffff )
                                            {   W( connection_state->buffer );
                                                connection_state->buffer = 0;
                                                break;
                                            }
                                        }
                                        E_flow_Q_report_timed_I_signal( connection_state->report_id );
                                        break;
                                    }
                                }
                                break;
                            }
                        }
                    }
                    tail = ( tail + 1 ) % count;
                }while( tail != head );
                if( !tail )
                    tail = count;
                *( N32 * )(( Pc )interface->register_memory + 0x2818 ) = tail - 1;
            }
        }
    }
    U_L( E_flow_S_scheduler[ sched_i ].state, inside_interrupt );
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
_internal
N16
E_ethernet_I_eeprom_read( struct E_net_Z_interface *interface
, N8 offset
){  *( N32 * )(( Pc )interface->register_memory + 0x14 ) = (( N32 )offset << 8 ) | 1;
    N time;
    E_flow_Q_spin_time_M( &time, 100000 ); //NDFN
    while( !( *( N32 *)(( Pc )interface->register_memory + 0x14 ) & ( 1 << 4 ))
    && !E_flow_Q_spin_time_T( &time )
    )
        __asm__ volatile (
        "\n"    "pause"
        );
    if( *( N32 * )(( Pc )interface->register_memory + 0x14 ) & 1 ) //TEST
        G( "EEPROM still reading" );
    return *( N32 * )(( Pc )interface->register_memory + 0x14 ) >> 16;
}
_private
N
E_ethernet_I_init( volatile P register_address
, volatile P eeprom_address
){  G( "Ethernet" );
    I interface_id = E_mem_Q_tab_I_add( E_net_S_interface );
    if( interface_id < 0 )
        return ~0;
    struct E_net_Z_interface *interface = E_mem_Q_tab_R( E_net_S_interface, interface_id );
    interface->register_memory = register_address;
    interface->eeprom_memory = eeprom_address;
    if( *( N32 * )interface->register_memory & ( 1 << 26 ))
    {   *( N32 * )interface->register_memory &= ~( 1 << 26 );
        E_flow_I_sleep(1);
    }
    *( N32 * )interface->register_memory |= 1 << 26;
    E_flow_I_sleep(1);
    N time;
    E_flow_Q_spin_time_M( &time, 1000000 ); //NDFN
    while(( *( N32 * )interface->register_memory & ( 1 << 26 ))
    && !E_flow_Q_spin_time_T( &time )
    )
        __asm__ volatile (
        "\n"    "pause"
        );
    if( *( N32 * )interface->register_memory & ( 1 << 26 ))
        return ~1;
    N16 a_0 = E_ethernet_I_eeprom_read( interface, 0 );
    N16 a_1 = E_ethernet_I_eeprom_read( interface, 1 );
    N16 a_2 = E_ethernet_I_eeprom_read( interface, 2 );
    interface->mac_address[0] = a_0 & 0xff;
    interface->mac_address[1] = a_0 >> 8;
    interface->mac_address[2] = a_1 & 0xff;
    interface->mac_address[3] = a_1 >> 8;
    interface->mac_address[4] = a_2 & 0xff;
    interface->mac_address[5] = a_2 >> 8;
    *( N64 * )(( Pc )interface->register_memory + 0x5400 ) = ( 1ULL << 63 ) | (( N64 )a_2 << 32 ) | (( N64 )a_1 << 16 ) | a_0;
    for_n( i, 128 )
        *( N32 * )(( Pc )interface->register_memory + 0x5200 + i * sizeof( N32 )) = 0;
    *( N32 * )(( Pc )interface->register_memory + 0x410 ) = ( 6 << 20 ) | ( 8 << 10 ) | 10;
    *( N32 * )(( Pc )interface->register_memory + 0x2828 ) = 1 << 24;
    *( N32 * )(( Pc )interface->register_memory + 0x3828 ) = 1 << 24;
    *( N32 * )(( Pc )interface->register_memory + 0x178 ) = 1 << 31;
    *( N32 * )interface->register_memory &= ~( 1 << 3 );
    *( N32 * )(( Pc )interface->register_memory + 0xd8 ) = 0xffffffff;
    *( N32 * )(( Pc )interface->register_memory + 0xd0 ) = ( 1 << 7 ) | ( 1 << 6 ) | ( 1 << 4 ) | ( 1 << 3 ) | ( 1 << 2 ) | ( 1 << 0 );
    struct E_ethernet_Z_receive_descriptor *receive_descriptors = E_mem_Q_blk_M_align_tab( sizeof( struct E_ethernet_Z_receive_descriptor ), 8, 16 );
    *( N64 * )(( Pc )interface->register_memory + 0x2800 ) = (N)E_main_Z_p_I_to_physical( receive_descriptors );
    *( N32 * )(( Pc )interface->register_memory + 0x2808 ) = 1 << 7;
    for_n_( i, 8 )
    {   receive_descriptors[i].length = E_ethernet_S_receive_buffer_size;
        P buffer = E_mem_Q_blk_M_align( receive_descriptors[i].length, 4096 );
        if( !buffer )
            return ~1;
        receive_descriptors[i].buffer_address = (N)E_main_Z_p_I_to_physical(buffer);
        receive_descriptors[i].pif = receive_descriptors[i].ipcs = receive_descriptors[i].tcpcs = receive_descriptors[i].reserved_0 = receive_descriptors[i].vp = receive_descriptors[i].ixsm = receive_descriptors[i].eop = receive_descriptors[i].dd = 0;
    }
    *( N32 * )(( Pc )interface->register_memory + 0x2818 ) = 8 - 1;
    *( N32 * )(( Pc )interface->register_memory + 0x100 ) = ( 1 << 25 ) | ( 1 << 16 ) | ( 1 << 5 ) | ( 1 << 1 );
    struct E_ethernet_Z_transmit_descriptor *transmit_descriptors = E_mem_Q_blk_M_align_tab( sizeof( struct E_ethernet_Z_transmit_descriptor ), 8, 16 );
    *( N64 * )(( Pc )interface->register_memory + 0x3800 ) = (N)E_main_Z_p_I_to_physical( transmit_descriptors );
    *( N32 * )(( Pc )interface->register_memory + 0x3808 ) = 1 << 7;
    for_n_( i, 8 )
        transmit_descriptors[i].dd = yes;
    *( N32 * )(( Pc )interface->register_memory + 0x400 ) = ( 0x40 << 12 ) | ( 1 << 3 ) | ( 1 << 1 );
    interface->dhcp.state = E_net_Z_interface_state_S_dhcp_discover;
    interface->dhcp.connection_id = ~0;
    interface->dhcp.retry = 0;
    interface->dhcp.xid = E_flow_I_current_time() & 0xffffffff;
    Yi_A( net, dhcp );
    Yi_F( net, dhcp, 0 );
    return 0;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
_private
N
E_ethernet_I_transmit( struct E_net_Z_interface *interface
, P packet
, N packet_l
){  N32 count = *( N32 * )(( Pc )interface->register_memory + 0x3808 ) / sizeof( struct E_ethernet_Z_transmit_descriptor );
    N part_count = packet_l / E_ethernet_S_receive_buffer_size + ( packet_l % E_ethernet_S_receive_buffer_size ? 1 : 0 );
    if( part_count > count - 1 )
        return ~0;
    E_flow_I_cli();
    N32 head = *( N32 * )(( Pc )interface->register_memory + 0x3810 ) % count;
    N32 tail = *( N32 * )(( Pc )interface->register_memory + 0x3818 );
    struct E_ethernet_Z_transmit_descriptor *transmit_descriptors = E_main_Z_p_I_to_virtual( (P)*( N64 * )(( Pc )interface->register_memory + 0x3800 ));
    if(( tail < head
      && part_count > head - 1 - tail
    )
    || ( tail > head
      && part_count > count - 1 - tail + head
    ))
    {   if( E_mem_Q_blk_I_append( &E_ethernet_S_transmit_queue, 1 ))
        {   E_flow_I_sti();
            return ~0;
        }
        E_ethernet_S_transmit_queue_n++;
        E_ethernet_S_transmit_queue[ E_ethernet_S_transmit_queue_n - 1 ].buffer = packet;
        E_ethernet_S_transmit_queue[ E_ethernet_S_transmit_queue_n - 1 ].buffer_l = packet_l;
        E_flow_I_sti();
        return 0;
    }
    N last;
    for_n( i, part_count )
    {   _0_( &transmit_descriptors[tail] );
        transmit_descriptors[tail].buffer_address = ( N64 )E_main_Z_p_I_to_physical(packet) + i * E_ethernet_S_receive_buffer_size;
        transmit_descriptors[tail].length = E_ethernet_S_receive_buffer_size;
        transmit_descriptors[tail].rs = 1;
        last = tail;
        tail = ( tail + 1 ) % count;
    }
    transmit_descriptors[last].length = packet_l % E_ethernet_S_receive_buffer_size;
    transmit_descriptors[last].ifcs = 1;
    transmit_descriptors[last].eop = 1;
    *( N32 * )(( Pc )interface->register_memory + 0x3818 ) = tail;
    E_flow_I_sti();
    return 0;
}
/******************************************************************************/