Changes in / [86c71de:47a89fe] in mainline


Ignore:
Files:
28 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/arm32/include/mm/km.h

    r86c71de r47a89fe  
    3939
    4040#define KM_ARM32_IDENTITY_START         UINT32_C(0x80000000)
    41 #define KM_ARM32_IDENTITY_SIZE          UINT32_C(0x70000000)
     41#define KM_ARM32_IDENTITY_SIZE          UINT32_C(0x40000000)
    4242
    43 #define KM_ARM32_NON_IDENTITY_START     UINT32_C(0xf0000000)
    44 /*
    45  * The last virtual megabyte contains the high exception vectors (0xFFFF0000).
    46  * Do not include this range into kernel non-identity.
    47  */
    48 #define KM_ARM32_NON_IDENTITY_SIZE      UINT32_C(0x0ff00000)
     43#define KM_ARM32_NON_IDENTITY_START     UINT32_C(0xc0000000)
     44#define KM_ARM32_NON_IDENTITY_SIZE      UINT32_C(0x40000000)
    4945
    5046extern void km_identity_arch_init(void);

  • kernel/arch/arm32/src/mm/page.c

    r86c71de r47a89fe  
    6565                page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
    6666       
     67        /* Create mapping for exception table at high offset */
    6768#ifdef HIGH_EXCEPTION_VECTORS
    68         /* Create mapping for exception table at high offset */
    69         uintptr_t ev_frame = (uintptr_t) frame_alloc(ONE_FRAME, FRAME_NONE);
    70         page_mapping_insert(AS_KERNEL, EXC_BASE_ADDRESS, ev_frame, flags);
     69        // XXX: fixme to use proper non-identity page
     70        void *virtaddr = frame_alloc(ONE_FRAME, FRAME_KA);
     71        page_mapping_insert(AS_KERNEL, EXC_BASE_ADDRESS, KA2PA(virtaddr),
     72            flags);
    7173#else
    7274#error "Only high exception vector supported now"
    7375#endif
     76        cur = ALIGN_DOWN(0x50008010, FRAME_SIZE);
     77        page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
    7478
    7579        page_table_unlock(AS_KERNEL, true);

  • kernel/arch/ia32/src/mm/frame.c

    r86c71de r47a89fe  
    5454       
    5555        for (i = 0; i < e820counter; i++) {
    56                 uint64_t base64 = e820table[i].base_address;
    57                 uint64_t size64 = e820table[i].size;
    58 
    59 #ifdef KARCH_ia32
    60                 /*
    61                  * Restrict the e820 table entries to 32-bits.
    62                  */
    63                 if (base64 >= 0x100000000ULL)
    64                         continue;
    65                 if (base64 + size64 > 0x100000000ULL)
    66                         size64 -= base64 + size64 - 0x100000000ULL;
    67 #endif
    68 
    69                 uintptr_t base = (uintptr_t) base64;
    70                 size_t size = (size_t) size64;
     56                uintptr_t base = (uintptr_t) e820table[i].base_address;
     57                size_t size = (size_t) e820table[i].size;
    7158               
    7259                if (!frame_adjust_zone_bounds(low, &base, &size))

  • kernel/genarch/src/mm/page_pt.c

    r86c71de r47a89fe  
    322322
    323323        ASSERT(ispwr2(ptl0step));
    324         ASSERT(size > 0);
    325 
    326         for (addr = ALIGN_DOWN(base, ptl0step); addr - 1 < base + size - 1;
     324
     325        for (addr = ALIGN_DOWN(base, ptl0step); addr < base + size;
    327326            addr += ptl0step) {
    328327                uintptr_t l1;

  • kernel/generic/include/mm/frame.h

    r86c71de r47a89fe  
    8383#define FRAME_TO_ZONE_FLAGS(ff) \
    8484        ((((ff) & FRAME_LOWMEM) ? ZONE_LOWMEM : \
    85             (((ff) & FRAME_HIGHMEM) ? ZONE_HIGHMEM : \
    86             ZONE_LOWMEM /* | ZONE_HIGHMEM */)) | \
    87             ZONE_AVAILABLE)
     85            (((ff) & FRAME_HIGHMEM) ? ZONE_HIGHMEM : ZONE_NONE)) | \
     86            (ZONE_AVAILABLE | ZONE_LOWMEM /* | ZONE_HIGHMEM */))
    8887
    8988#define ZONE_FLAGS_MATCH(zf, f) \

  • kernel/generic/include/mm/km.h

    r86c71de r47a89fe  
    3737
    3838#include <typedefs.h>
    39 #include <mm/frame.h>
    4039
    4140extern void km_identity_init(void);
    … …  
    4948extern bool km_is_non_identity(uintptr_t);
    5049
    51 extern uintptr_t km_temporary_page_get(uintptr_t *, frame_flags_t);
    52 extern void km_temporary_page_put(uintptr_t);
    53 
    5450#endif
    5551

  • kernel/generic/src/mm/backend_anon.c

    r86c71de r47a89fe  
    4444#include <mm/frame.h>
    4545#include <mm/slab.h>
    46 #include <mm/km.h>
    4746#include <synch/mutex.h>
    4847#include <adt/list.h>
    … …  
    156155int anon_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
    157156{
    158         uintptr_t upage = ALIGN_DOWN(addr, PAGE_SIZE);
    159         uintptr_t kpage;
    160157        uintptr_t frame;
    161158
    … …  
    178175                mutex_lock(&area->sh_info->lock);
    179176                frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
    180                     upage - area->base, &leaf);
     177                    ALIGN_DOWN(addr, PAGE_SIZE) - area->base, &leaf);
    181178                if (!frame) {
    182179                        bool allocate = true;
    … …  
    188185                         */
    189186                        for (i = 0; i < leaf->keys; i++) {
    190                                 if (leaf->key[i] == upage - area->base) {
     187                                if (leaf->key[i] ==
     188                                    ALIGN_DOWN(addr, PAGE_SIZE) - area->base) {
    191189                                        allocate = false;
    192190                                        break;
    … …  
    194192                        }
    195193                        if (allocate) {
    196                                 kpage = km_temporary_page_get(&frame,
    197                                     FRAME_NO_RESERVE);
    198                                 memsetb((void *) kpage, PAGE_SIZE, 0);
    199                                 km_temporary_page_put(kpage);
     194                                frame = (uintptr_t) frame_alloc_noreserve(
     195                                    ONE_FRAME, 0);
     196                                memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
    200197                               
    201198                                /*
    … …  
    204201                                 */
    205202                                btree_insert(&area->sh_info->pagemap,
    206                                     upage - area->base, (void *) frame, leaf);
     203                                    ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
     204                                    (void *) frame, leaf);
    207205                        }
    208206                }
    … …  
    225223                 *   the different causes
    226224                 */
    227                 kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
    228                 memsetb((void *) kpage, PAGE_SIZE, 0);
    229                 km_temporary_page_put(kpage);
     225                frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME, 0);
     226                memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
    230227        }
    231228       
    232229        /*
    233          * Map 'upage' to 'frame'.
     230         * Map 'page' to 'frame'.
    234231         * Note that TLB shootdown is not attempted as only new information is
    235232         * being inserted into page tables.
    236233         */
    237         page_mapping_insert(AS, upage, frame, as_area_get_flags(area));
    238         if (!used_space_insert(area, upage, 1))
     234        page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
     235        if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
    239236                panic("Cannot insert used space.");
    240237               

  • kernel/generic/src/mm/backend_elf.c

    r86c71de r47a89fe  
    4444#include <mm/page.h>
    4545#include <mm/reserve.h>
    46 #include <mm/km.h>
    4746#include <genarch/mm/page_pt.h>
    4847#include <genarch/mm/page_ht.h>
    … …  
    230229        elf_segment_header_t *entry = area->backend_data.segment;
    231230        btree_node_t *leaf;
    232         uintptr_t base;
    233         uintptr_t frame;
    234         uintptr_t kpage;
    235         uintptr_t upage;
    236         uintptr_t start_anon;
     231        uintptr_t base, frame, page, start_anon;
    237232        size_t i;
    238233        bool dirty = false;
    … …  
    254249            (((void *) elf) + ALIGN_DOWN(entry->p_offset, PAGE_SIZE));
    255250
    256         /* Virtual address of faulting page */
    257         upage = ALIGN_DOWN(addr, PAGE_SIZE);
     251        /* Virtual address of faulting page*/
     252        page = ALIGN_DOWN(addr, PAGE_SIZE);
    258253
    259254        /* Virtual address of the end of initialized part of segment */
    … …  
    269264                mutex_lock(&area->sh_info->lock);
    270265                frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
    271                     upage - area->base, &leaf);
     266                    page - area->base, &leaf);
    272267                if (!frame) {
    273268                        unsigned int i;
    … …  
    278273
    279274                        for (i = 0; i < leaf->keys; i++) {
    280                                 if (leaf->key[i] == upage - area->base) {
     275                                if (leaf->key[i] == page - area->base) {
    281276                                        found = true;
    282277                                        break;
    … …  
    286281                if (frame || found) {
    287282                        frame_reference_add(ADDR2PFN(frame));
    288                         page_mapping_insert(AS, upage, frame,
     283                        page_mapping_insert(AS, addr, frame,
    289284                            as_area_get_flags(area));
    290                         if (!used_space_insert(area, upage, 1))
     285                        if (!used_space_insert(area, page, 1))
    291286                                panic("Cannot insert used space.");
    292287                        mutex_unlock(&area->sh_info->lock);
    … …  
    299294         * mapping.
    300295         */
    301         if (upage >= entry->p_vaddr && upage + PAGE_SIZE <= start_anon) {
     296        if (page >= entry->p_vaddr && page + PAGE_SIZE <= start_anon) {
    302297                /*
    303298                 * Initialized portion of the segment. The memory is backed
    … …  
    309304                 */
    310305                if (entry->p_flags & PF_W) {
    311                         kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
    312                         memcpy((void *) kpage, (void *) (base + i * PAGE_SIZE),
    313                             PAGE_SIZE);
     306                        frame = (uintptr_t)frame_alloc_noreserve(ONE_FRAME, 0);
     307                        memcpy((void *) PA2KA(frame),
     308                            (void *) (base + i * FRAME_SIZE), FRAME_SIZE);
    314309                        if (entry->p_flags & PF_X) {
    315                                 smc_coherence_block((void *) kpage, PAGE_SIZE);
     310                                smc_coherence_block((void *) PA2KA(frame),
     311                                    FRAME_SIZE);
    316312                        }
    317                         km_temporary_page_put(kpage);
    318313                        dirty = true;
    319314                } else {
    320315                        frame = KA2PA(base + i * FRAME_SIZE);
    321316                }       
    322         } else if (upage >= start_anon) {
     317        } else if (page >= start_anon) {
    323318                /*
    324319                 * This is the uninitialized portion of the segment.
    … …  
    327322                 * and cleared.
    328323                 */
    329                 kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
    330                 memsetb((void *) kpage, PAGE_SIZE, 0);
    331                 km_temporary_page_put(kpage);
     324                frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME, 0);
     325                memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
    332326                dirty = true;
    333327        } else {
    … …  
    340334                 * (The segment can be and often is shorter than 1 page).
    341335                 */
    342                 if (upage < entry->p_vaddr)
    343                         pad_lo = entry->p_vaddr - upage;
     336                if (page < entry->p_vaddr)
     337                        pad_lo = entry->p_vaddr - page;
    344338                else
    345339                        pad_lo = 0;
    346340
    347                 if (start_anon < upage + PAGE_SIZE)
    348                         pad_hi = upage + PAGE_SIZE - start_anon;
     341                if (start_anon < page + PAGE_SIZE)
     342                        pad_hi = page + PAGE_SIZE - start_anon;
    349343                else
    350344                        pad_hi = 0;
    351345
    352                 kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
    353                 memcpy((void *) (kpage + pad_lo),
    354                     (void *) (base + i * PAGE_SIZE + pad_lo),
    355                     PAGE_SIZE - pad_lo - pad_hi);
     346                frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME, 0);
     347                memcpy((void *) (PA2KA(frame) + pad_lo),
     348                    (void *) (base + i * FRAME_SIZE + pad_lo),
     349                    FRAME_SIZE - pad_lo - pad_hi);
    356350                if (entry->p_flags & PF_X) {
    357                         smc_coherence_block((void *) (kpage + pad_lo),
    358                             PAGE_SIZE - pad_lo - pad_hi);
     351                        smc_coherence_block((void *) (PA2KA(frame) + pad_lo),
     352                            FRAME_SIZE - pad_lo - pad_hi);
    359353                }
    360                 memsetb((void *) kpage, pad_lo, 0);
    361                 memsetb((void *) (kpage + PAGE_SIZE - pad_hi), pad_hi, 0);
    362                 km_temporary_page_put(kpage);
     354                memsetb((void *) PA2KA(frame), pad_lo, 0);
     355                memsetb((void *) (PA2KA(frame) + FRAME_SIZE - pad_hi), pad_hi,
     356                    0);
    363357                dirty = true;
    364358        }
    … …  
    366360        if (dirty && area->sh_info) {
    367361                frame_reference_add(ADDR2PFN(frame));
    368                 btree_insert(&area->sh_info->pagemap, upage - area->base,
     362                btree_insert(&area->sh_info->pagemap, page - area->base,
    369363                    (void *) frame, leaf);
    370364        }
    … …  
    373367                mutex_unlock(&area->sh_info->lock);
    374368
    375         page_mapping_insert(AS, upage, frame, as_area_get_flags(area));
    376         if (!used_space_insert(area, upage, 1))
     369        page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
     370        if (!used_space_insert(area, page, 1))
    377371                panic("Cannot insert used space.");
    378372

  • kernel/generic/src/mm/km.c

    r86c71de r47a89fe  
    3939#include <arch/mm/km.h>
    4040#include <mm/page.h>
    41 #include <mm/frame.h>
    42 #include <mm/asid.h>
    4341#include <config.h>
    4442#include <typedefs.h>
    4543#include <lib/ra.h>
    4644#include <debug.h>
    47 #include <arch.h>
    4845
    4946static ra_arena_t *km_ni_arena;
    50 
    51 #define DEFERRED_PAGES_MAX      (PAGE_SIZE / sizeof(uintptr_t))
    52 
    53 /** Number of freed pages in the deferred buffer. */
    54 static volatile unsigned deferred_pages;
    55 /** Buffer of deferred freed pages. */
    56 static uintptr_t deferred_page[DEFERRED_PAGES_MAX];
    57 
    58 /** Flush the buffer of deferred freed pages.
    59  *
    60  * @return              Number of freed pages.
    61  */
    62 static unsigned km_flush_deferred(void)
    63 {
    64         unsigned i = 0;
    65         ipl_t ipl;
    66 
    67         ipl = tlb_shootdown_start(TLB_INVL_ASID, ASID_KERNEL, 0, 0);
    68 
    69         for (i = 0; i < deferred_pages; i++) {
    70                 page_mapping_remove(AS_KERNEL, deferred_page[i]);
    71                 km_page_free(deferred_page[i], PAGE_SIZE);
    72         }
    73 
    74         tlb_invalidate_asid(ASID_KERNEL);
    75 
    76         as_invalidate_translation_cache(AS_KERNEL, 0, -1);
    77         tlb_shootdown_finalize(ipl);
    78 
    79         return i;
    80 }
    8147
    8248/** Architecture dependent setup of identity-mapped kernel memory. */
    … …  
    12187}
    12288
    123 /** Unmap kernen non-identity page.
    124  *
    125  * @param[in] page      Non-identity page to be unmapped.
    126  */
    127 static void km_unmap_deferred(uintptr_t page)
    128 {
    129         page_table_lock(AS_KERNEL, true);
    130 
    131         if (deferred_pages == DEFERRED_PAGES_MAX) {
    132                 (void) km_flush_deferred();
    133                 deferred_pages = 0;
    134         }
    135 
    136         deferred_page[deferred_pages++] = page;
    137 
    138         page_table_unlock(AS_KERNEL, true);
    139 }
    140 
    141 /** Create a temporary page.
    142  *
    143  * The page is mapped read/write to a newly allocated frame of physical memory.
    144  * The page must be returned back to the system by a call to
    145  * km_temporary_page_put().
    146  *
    147  * @param[inout] framep Pointer to a variable which will receive the physical
    148  *                      address of the allocated frame.
    149  * @param[in] flags     Frame allocation flags. FRAME_NONE or FRAME_NO_RESERVE.
    150  * @return              Virtual address of the allocated frame.
    151  */
    152 uintptr_t km_temporary_page_get(uintptr_t *framep, frame_flags_t flags)
    153 {
    154         uintptr_t frame;
    155         uintptr_t page;
    156 
    157         ASSERT(THREAD);
    158         ASSERT(framep);
    159         ASSERT(!(flags & ~FRAME_NO_RESERVE));
    160 
    161         /*
    162          * Allocate a frame, preferably from high memory.
    163          */
    164         frame = (uintptr_t) frame_alloc(ONE_FRAME,
    165             FRAME_HIGHMEM | FRAME_ATOMIC | flags);
    166         if (frame) {
    167                 page = km_page_alloc(PAGE_SIZE, PAGE_SIZE);
    168                 ASSERT(page);   // FIXME
    169                 page_table_lock(AS_KERNEL, true);
    170                 page_mapping_insert(AS_KERNEL, page, frame,
    171                     PAGE_CACHEABLE | PAGE_READ | PAGE_WRITE);
    172                 page_table_unlock(AS_KERNEL, true);
    173         } else {
    174                 frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME,
    175                     FRAME_LOWMEM);
    176                 page = PA2KA(frame);
    177         }
    178 
    179         *framep = frame;
    180         return page;   
    181 }
    182 
    183 /** Destroy a temporary page.
    184  *
    185  * This function destroys a temporary page previously created by
    186  * km_temporary_page_get(). The page destruction may be immediate or deferred.
    187  * The frame mapped by the destroyed page is not freed.
    188  *
    189  * @param[in] page      Temporary page to be destroyed.
    190  */
    191 void km_temporary_page_put(uintptr_t page)
    192 {
    193         ASSERT(THREAD);
    194 
    195         if (km_is_non_identity(page))
    196                 km_unmap_deferred(page);
    197 }
    19889
    19990/** @}

  • kernel/generic/src/mm/page.c

    r86c71de r47a89fe  
    202202        asize = ALIGN_UP(size, PAGE_SIZE);
    203203        align = ispwr2(size) ? size : (1U << (fnzb(size) + 1));
    204         virtaddr = km_page_alloc(asize, max(PAGE_SIZE, align));
     204        virtaddr = km_page_alloc(asize, align);
    205205
    206206        page_table_lock(AS_KERNEL, true);

  • uspace/drv/nic/e1k/e1k.c

    r86c71de r47a89fe  
    5252#include <nil_remote.h>
    5353#include <ops/nic.h>
     54#include <packet_client.h>
     55#include <packet_remote.h>
     56#include <net/packet_header.h>
    5457#include "e1k.h"
    5558
    … …  
    5962
    6063/* Must be power of 8 */
    61 #define E1000_RX_FRAME_COUNT  128
    62 #define E1000_TX_FRAME_COUNT  128
     64#define E1000_RX_PACKETS_COUNT  128
     65#define E1000_TX_PACKETS_COUNT  128
    6366
    6467#define E1000_RECEIVE_ADDRESS  16
    6568
    66 /** Maximum sending frame size */
     69/** Maximum sending packet size */
    6770#define E1000_MAX_SEND_FRAME_SIZE  2048
    68 /** Maximum receiving frame size */
    69 #define E1000_MAX_RECEIVE_FRAME_SIZE  2048
     71/** Maximum receiving packet size */
     72#define E1000_MAX_RECEIVE_PACKET_SIZE  2048
    7073
    7174/** nic_driver_data_t* -> e1000_t* cast */
    … …  
    134137        void *rx_ring_virt;
    135138       
    136         /** Ring of RX frames, physical address */
    137         void **rx_frame_phys;
    138         /** Ring of RX frames, virtual address */
    139         void **rx_frame_virt;
     139        /** Packets in rx ring  */
     140        packet_t **rx_ring_packets;
    140141       
    141142        /** VLAN tag */
    142143        uint16_t vlan_tag;
    143144       
    144         /** Add VLAN tag to frame */
     145        /** Add VLAN tag to packet */
    145146        bool vlan_tag_add;
    146147       
    … …  
    476477}
    477478
    478 /** Get state of acceptance of weird frames
     479/** Get state of acceptance of weird packets
    479480 *
    480481 * @param      device Device to check
    … …  
    494495};
    495496
    496 /** Set acceptance of weird frames
     497/** Set acceptance of weird packets
    497498 *
    498499 * @param device Device to update
    … …  
    678679}
    679680
    680 /** Disable receiving frames for default address
     681/** Disable receiving packets for default address
    681682 *
    682683 * @param e1000 E1000 data structure
    … …  
    690691}
    691692
    692 /** Enable receiving frames for default address
     693/** Enable receiving packets for default address
    693694 *
    694695 * @param e1000 E1000 data structure
    … …  
    750751}
    751752
    752 /** Enable accepting of broadcast frames
     753/** Enable accepting of broadcast packets
    753754 *
    754755 * @param e1000 E1000 data structure
    … …  
    762763}
    763764
    764 /** Disable accepting of broadcast frames
     765/** Disable accepting of broadcast packets
    765766 *
    766767 * @param e1000 E1000 data structure
    … …  
    798799}
    799800
    800 /** Set multicast frames acceptance mode
     801/** Set multicast packets acceptance mode
    801802 *
    802803 * @param nic      NIC device to update
    … …  
    852853}
    853854
    854 /** Set unicast frames acceptance mode
     855/** Set unicast packets acceptance mode
    855856 *
    856857 * @param nic      NIC device to update
    … …  
    910911}
    911912
    912 /** Set broadcast frames acceptance mode
     913/** Set broadcast packets acceptance mode
    913914 *
    914915 * @param nic  NIC device to update
    … …  
    995996        if (vlan_mask) {
    996997                /*
    997                  * Disable receiving, so that frame matching
     998                 * Disable receiving, so that packet matching
    998999                 * partially written VLAN is not received.
    9991000                 */
    … …  
    10621063}
    10631064
    1064 /** Fill receive descriptor with new empty buffer
    1065  *
    1066  * Store frame in e1000->rx_frame_phys
     1065/** Fill receive descriptor with new empty packet
     1066 *
     1067 * Store packet in e1000->rx_ring_packets
    10671068 *
    10681069 * @param nic    NIC data stricture
    … …  
    10731074{
    10741075        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1075        
     1076        packet_t *packet =
     1077            nic_alloc_packet(nic, E1000_MAX_RECEIVE_PACKET_SIZE);
     1078       
     1079        assert(packet);
     1080       
     1081        *(e1000->rx_ring_packets + offset) = packet;
    10761082        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    10771083            (e1000->rx_ring_virt + offset * sizeof(e1000_rx_descriptor_t));
    10781084       
    1079         rx_descriptor->phys_addr = PTR_TO_U64(e1000->rx_frame_phys[offset]);
     1085        void *phys;
     1086        int rc =
     1087            nic_dma_lock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE, &phys);
     1088       
     1089        if (rc == EOK)
     1090                rx_descriptor->phys_addr = PTR_TO_U64(phys + packet->data_start);
     1091        else
     1092                rx_descriptor->phys_addr = 0;
     1093       
    10801094        rx_descriptor->length = 0;
    10811095        rx_descriptor->checksum = 0;
    … …  
    11411155}
    11421156
    1143 /** Receive frames
     1157/** Receive packets
    11441158 *
    11451159 * @param nic NIC data
    11461160 *
    11471161 */
    1148 static void e1000_receive_frames(nic_t *nic)
     1162static void e1000_receive_packets(nic_t *nic)
    11491163{
    11501164        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    … …  
    11531167       
    11541168        uint32_t *tail_addr = E1000_REG_ADDR(e1000, E1000_RDT);
    1155         uint32_t next_tail = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
     1169        uint32_t next_tail = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
    11561170       
    11571171        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    … …  
    11591173       
    11601174        while (rx_descriptor->status & 0x01) {
    1161                 uint32_t frame_size = rx_descriptor->length - E1000_CRC_SIZE;
     1175                uint32_t packet_size = rx_descriptor->length - E1000_CRC_SIZE;
    11621176               
    1163                 nic_frame_t *frame = nic_alloc_frame(nic, frame_size);
    1164                 if (frame != NULL) {
    1165                         memcpy(frame->data, e1000->rx_frame_virt[next_tail], frame_size);
    1166                         nic_received_frame(nic, frame);
    1167                 } else {
    1168                         ddf_msg(LVL_ERROR, "Memory allocation failed. Frame dropped.");
    1169                 }
     1177                packet_t *packet = *(e1000->rx_ring_packets + next_tail);
     1178                packet_suffix(packet, packet_size);
     1179               
     1180                nic_dma_unlock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE);
     1181                nic_received_packet(nic, packet);
    11701182               
    11711183                e1000_fill_new_rx_descriptor(nic, next_tail);
    11721184               
    1173                 *tail_addr = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
    1174                 next_tail = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
     1185                *tail_addr = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
     1186                next_tail = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
    11751187               
    11761188                rx_descriptor = (e1000_rx_descriptor_t *)
    … …  
    12131225{
    12141226        if (icr & ICR_RXT0)
    1215                 e1000_receive_frames(nic);
     1227                e1000_receive_packets(nic);
    12161228}
    12171229
    … …  
    12621274}
    12631275
    1264 /** Force receiving all frames in the receive buffer
     1276/** Force receiving all packets in the receive buffer
    12651277 *
    12661278 * @param nic NIC data
    … …  
    13351347static void e1000_initialize_rx_registers(e1000_t *e1000)
    13361348{
    1337         E1000_REG_WRITE(e1000, E1000_RDLEN, E1000_RX_FRAME_COUNT * 16);
     1349        E1000_REG_WRITE(e1000, E1000_RDLEN, E1000_RX_PACKETS_COUNT * 16);
    13381350        E1000_REG_WRITE(e1000, E1000_RDH, 0);
    13391351       
    13401352        /* It is not posible to let HW use all descriptors */
    1341         E1000_REG_WRITE(e1000, E1000_RDT, E1000_RX_FRAME_COUNT - 1);
     1353        E1000_REG_WRITE(e1000, E1000_RDT, E1000_RX_PACKETS_COUNT - 1);
    13421354       
    13431355        /* Set Broadcast Enable Bit */
    … …  
    13591371       
    13601372        int rc = dmamem_map_anonymous(
    1361             E1000_RX_FRAME_COUNT * sizeof(e1000_rx_descriptor_t),
     1373            E1000_RX_PACKETS_COUNT * sizeof(e1000_rx_descriptor_t),
    13621374            AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->rx_ring_phys,
    13631375            &e1000->rx_ring_virt);
    … …  
    13701382            (uint32_t) PTR_TO_U64(e1000->rx_ring_phys));
    13711383       
    1372         e1000->rx_frame_phys =
    1373             calloc(E1000_RX_FRAME_COUNT, sizeof(void *));
    1374         e1000->rx_frame_virt =
    1375             calloc(E1000_RX_FRAME_COUNT, sizeof(void *));
    1376         if (e1000->rx_frame_phys == NULL || e1000->rx_frame_virt == NULL) {
    1377                 rc = ENOMEM;
    1378                 goto error;
    1379         }
    1380        
    1381         size_t i;
    1382         void *frame_virt;
    1383         void *frame_phys;
    1384        
    1385         for (i = 0; i < E1000_RX_FRAME_COUNT; i++) {
    1386                 rc = dmamem_map_anonymous(
    1387                     E1000_MAX_SEND_FRAME_SIZE, AS_AREA_READ | AS_AREA_WRITE,
    1388                     0, &frame_phys, &frame_virt);
    1389                 if (rc != EOK)
    1390                         goto error;
    1391                
    1392                 e1000->rx_frame_virt[i] = frame_virt;
    1393                 e1000->rx_frame_phys[i] = frame_phys;
    1394         }
     1384        e1000->rx_ring_packets =
     1385            malloc(E1000_RX_PACKETS_COUNT * sizeof(packet_t *));
     1386        // FIXME: Check return value
    13951387       
    13961388        /* Write descriptor */
    1397         for (i = 0; i < E1000_RX_FRAME_COUNT; i++)
    1398                 e1000_fill_new_rx_descriptor(nic, i);
     1389        for (unsigned int offset = 0;
     1390            offset < E1000_RX_PACKETS_COUNT;
     1391            offset++)
     1392                e1000_fill_new_rx_descriptor(nic, offset);
    13991393       
    14001394        e1000_initialize_rx_registers(e1000);
    … …  
    14021396        fibril_mutex_unlock(&e1000->rx_lock);
    14031397        return EOK;
    1404 error:
    1405         for (i = 0; i < E1000_RX_FRAME_COUNT; i++) {
    1406                 if (e1000->rx_frame_virt[i] != NULL) {
    1407                         dmamem_unmap_anonymous(e1000->rx_frame_virt[i]);
    1408                         e1000->rx_frame_virt[i] = NULL;
    1409                         e1000->rx_frame_phys[i] = NULL;
    1410                 }
    1411         }
    1412         if (e1000->rx_frame_phys != NULL) {
    1413                 free(e1000->rx_frame_phys);
    1414                 e1000->rx_frame_phys = NULL;
    1415         }
    1416         if (e1000->rx_frame_virt != NULL) {
    1417                 free(e1000->rx_frame_virt);
    1418                 e1000->rx_frame_phys = NULL;
    1419         }
    1420         return rc;
    14211398}
    14221399
    … …  
    14301407        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    14311408       
    1432         /* Write descriptor */
    1433         for (unsigned int offset = 0; offset < E1000_RX_FRAME_COUNT; offset++) {
    1434                 dmamem_unmap_anonymous(e1000->rx_frame_virt[offset]);
    1435                 e1000->rx_frame_virt[offset] = NULL;
    1436                 e1000->rx_frame_phys[offset] = NULL;
    1437         }
    1438        
    1439         free(e1000->rx_frame_virt);
    1440         free(e1000->rx_frame_phys);
    1441         e1000->rx_frame_virt = NULL;
    1442         e1000->rx_frame_phys = NULL;
    1443         dmamem_unmap_anonymous(e1000->rx_ring_virt);
    1444 }
    1445 
    1446 /** Clear receive descriptor ring
    1447  *
    1448  * @param e1000 E1000 data
    1449  *
    1450  */
    1451 static void e1000_clear_rx_ring(e1000_t *e1000)
    1452 {
    14531409        /* Write descriptor */
    14541410        for (unsigned int offset = 0;
    1455             offset < E1000_RX_FRAME_COUNT;
     1411            offset < E1000_RX_PACKETS_COUNT;
     1412            offset++) {
     1413                packet_t *packet = *(e1000->rx_ring_packets + offset);
     1414                nic_dma_unlock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE);
     1415                nic_release_packet(nic, packet);
     1416        }
     1417       
     1418        free(e1000->rx_ring_packets);
     1419        dmamem_unmap_anonymous(e1000->rx_ring_virt);
     1420}
     1421
     1422/** Clear receive descriptor ring
     1423 *
     1424 * @param e1000 E1000 data
     1425 *
     1426 */
     1427static void e1000_clear_rx_ring(e1000_t *e1000)
     1428{
     1429        /* Write descriptor */
     1430        for (unsigned int offset = 0;
     1431            offset < E1000_RX_PACKETS_COUNT;
    14561432            offset++)
    14571433                e1000_clear_rx_descriptor(e1000, offset);
    … …  
    15221498static void e1000_initialize_tx_registers(e1000_t *e1000)
    15231499{
    1524         E1000_REG_WRITE(e1000, E1000_TDLEN, E1000_TX_FRAME_COUNT * 16);
     1500        E1000_REG_WRITE(e1000, E1000_TDLEN, E1000_TX_PACKETS_COUNT * 16);
    15251501        E1000_REG_WRITE(e1000, E1000_TDH, 0);
    15261502        E1000_REG_WRITE(e1000, E1000_TDT, 0);
    … …  
    15541530       
    15551531        int rc = dmamem_map_anonymous(
    1556             E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t),
     1532            E1000_TX_PACKETS_COUNT * sizeof(e1000_tx_descriptor_t),
    15571533            AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->tx_ring_phys,
    15581534            &e1000->tx_ring_virt);
    … …  
    15611537       
    15621538        bzero(e1000->tx_ring_virt,
    1563             E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t));
    1564        
    1565         e1000->tx_frame_phys = calloc(E1000_TX_FRAME_COUNT, sizeof(void *));
    1566         e1000->tx_frame_virt = calloc(E1000_TX_FRAME_COUNT, sizeof(void *));
     1539            E1000_TX_PACKETS_COUNT * sizeof(e1000_tx_descriptor_t));
     1540       
     1541        e1000->tx_frame_phys = calloc(E1000_TX_PACKETS_COUNT, sizeof(void *));
     1542        e1000->tx_frame_virt = calloc(E1000_TX_PACKETS_COUNT, sizeof(void *));
    15671543
    15681544        if (e1000->tx_frame_phys == NULL || e1000->tx_frame_virt == NULL) {
    … …  
    15711547        }
    15721548       
    1573         for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
     1549        for (i = 0; i < E1000_TX_PACKETS_COUNT; i++) {
    15741550                rc = dmamem_map_anonymous(
    15751551                    E1000_MAX_SEND_FRAME_SIZE, AS_AREA_READ | AS_AREA_WRITE,
    … …  
    15961572       
    15971573        if (e1000->tx_frame_phys != NULL && e1000->tx_frame_virt != NULL) {
    1598                 for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
     1574                for (i = 0; i < E1000_TX_PACKETS_COUNT; i++) {
    15991575                        if (e1000->tx_frame_virt[i] != NULL) {
    16001576                                dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
    … …  
    16271603        size_t i;
    16281604       
    1629         for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
     1605        for (i = 0; i < E1000_TX_PACKETS_COUNT; i++) {
    16301606                dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
    16311607                e1000->tx_frame_virt[i] = NULL;
    … …  
    16541630        /* Write descriptor */
    16551631        for (unsigned int offset = 0;
    1656             offset < E1000_TX_FRAME_COUNT;
     1632            offset < E1000_TX_PACKETS_COUNT;
    16571633            offset++)
    16581634                e1000_clear_tx_descriptor(nic, offset);
    … …  
    17111687}
    17121688
    1713 /** Activate the device to receive and transmit frames
     1689/** Activate the device to receive and transmit packets
    17141690 *
    17151691 * @param nic NIC driver data
    … …  
    20972073int e1000_dev_add(ddf_dev_t *dev)
    20982074{
    2099         ddf_fun_t *fun;
    21002075        assert(dev);
    21012076       
    … …  
    21282103        e1000_initialize_vlan(e1000);
    21292104       
    2130         fun = ddf_fun_create(nic_get_ddf_dev(nic), fun_exposed, "port0");
    2131         if (fun == NULL)
     2105        rc = nic_register_as_ddf_fun(nic, &e1000_dev_ops);
     2106        if (rc != EOK)
    21322107                goto err_tx_structure;
    2133         nic_set_ddf_fun(nic, fun);
    2134         fun->ops = &e1000_dev_ops;
    2135         fun->driver_data = nic;
    21362108       
    21372109        rc = e1000_register_int_handler(nic);
    21382110        if (rc != EOK)
    2139                 goto err_fun_create;
     2111                goto err_tx_structure;
    21402112       
    21412113        rc = nic_connect_to_services(nic);
    … …  
    21602132                goto err_rx_structure;
    21612133       
    2162         rc = ddf_fun_bind(fun);
    2163         if (rc != EOK)
    2164                 goto err_fun_bind;
    2165        
    2166         rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
    2167         if (rc != EOK)
    2168                 goto err_add_to_cat;
    2169        
    21702134        return EOK;
    21712135       
    2172 err_add_to_cat:
    2173         ddf_fun_unbind(fun);
    2174 err_fun_bind:
    21752136err_rx_structure:
    21762137        e1000_uninitialize_rx_structure(nic);
    21772138err_irq:
    21782139        unregister_interrupt_handler(dev, DRIVER_DATA_DEV(dev)->irq);
    2179 err_fun_create:
    2180         ddf_fun_destroy(fun);
    2181         nic_set_ddf_fun(nic, NULL);
    21822140err_tx_structure:
    21832141        e1000_uninitialize_tx_structure(e1000);
    … …  
    23252283       
    23262284        if (!descriptor_available) {
    2327                 /* Frame lost */
     2285                /* Packet lost */
    23282286                fibril_mutex_unlock(&e1000->tx_lock);
    23292287                return;
    … …  
    23542312       
    23552313        tdt++;
    2356         if (tdt == E1000_TX_FRAME_COUNT)
     2314        if (tdt == E1000_TX_PACKETS_COUNT)
    23572315                tdt = 0;
    23582316       

  • uspace/drv/nic/e1k/e1k.h

    r86c71de r47a89fe  
    3939#include <stdint.h>
    4040
    41 /** Ethernet CRC size after frame received in rx_descriptor */
     41/** Ethernet CRC size after packet received in rx_descriptor */
    4242#define E1000_CRC_SIZE  4
    4343
    … …  
    109109/** Transmit descriptor COMMAND field bits */
    110110typedef enum {
    111         TXDESCRIPTOR_COMMAND_VLE = (1 << 6),   /**< VLAN frame Enable */
     111        TXDESCRIPTOR_COMMAND_VLE = (1 << 6),   /**< VLAN Packet Enable */
    112112        TXDESCRIPTOR_COMMAND_RS = (1 << 3),    /**< Report Status */
    113113        TXDESCRIPTOR_COMMAND_IFCS = (1 << 1),  /**< Insert FCS */

  • uspace/drv/nic/lo/lo.c

    r86c71de r47a89fe  
    4242#include <async.h>
    4343#include <nic.h>
     44#include <packet_client.h>
    4445
    4546#define NAME  "lo"
    … …  
    6061static void lo_send_frame(nic_t *nic_data, void *data, size_t size)
    6162{
     63        packet_t *packet;
     64        int rc;
     65
     66        packet = nic_alloc_packet(nic_data, size);
     67        if (packet == NULL)
     68                return;
     69
     70        rc = packet_copy_data(packet, data, size);
     71        if (rc != EOK)
     72                return;
     73
    6274        nic_report_send_ok(nic_data, 1, size);
    63         nic_received_noneth_frame(nic_data, data, size);
     75        nic_received_noneth_packet(nic_data, packet);
    6476}
    6577
    … …  
    8092static int lo_dev_add(ddf_dev_t *dev)
    8193{
    82         ddf_fun_t *fun = NULL;
    83         bool bound = false;
    84        
    85         nic_t *nic = nic_create_and_bind(dev);
    86         if (nic == NULL) {
     94        nic_t *nic_data = nic_create_and_bind(dev);
     95        if (nic_data == NULL) {
    8796                printf("%s: Failed to initialize\n", NAME);
    8897                return ENOMEM;
    8998        }
    9099       
    91         dev->driver_data = nic;
    92         nic_set_send_frame_handler(nic, lo_send_frame);
     100        dev->driver_data = nic_data;
     101        nic_set_send_frame_handler(nic_data, lo_send_frame);
    93102       
    94         int rc = nic_connect_to_services(nic);
     103        int rc = nic_connect_to_services(nic_data);
    95104        if (rc != EOK) {
    96105                printf("%s: Failed to connect to services\n", NAME);
    97                 goto error;
     106                nic_unbind_and_destroy(dev);
     107                return rc;
    98108        }
    99109       
    100         fun = ddf_fun_create(nic_get_ddf_dev(nic), fun_exposed, "port0");
    101         if (fun == NULL) {
    102                 printf("%s: Failed creating function\n", NAME);
    103                 rc = ENOMEM;
    104                 goto error;
     110        rc = nic_register_as_ddf_fun(nic_data, &lo_dev_ops);
     111        if (rc != EOK) {
     112                printf("%s: Failed to register as DDF function\n", NAME);
     113                nic_unbind_and_destroy(dev);
     114                return rc;
    105115        }
    106         nic_set_ddf_fun(nic, fun);
    107         fun->ops = &lo_dev_ops;
    108         fun->driver_data = nic;
    109116       
    110         rc = nic_report_address(nic, &lo_addr);
     117        rc = nic_report_address(nic_data, &lo_addr);
    111118        if (rc != EOK) {
    112119                printf("%s: Failed to setup loopback address\n", NAME);
    113                 goto error;
     120                nic_unbind_and_destroy(dev);
     121                return rc;
    114122        }
    115        
    116         rc = ddf_fun_bind(fun);
    117         if (rc != EOK) {
    118                 printf("%s: Failed binding function\n", NAME);
    119                 goto error;
    120         }
    121         bound = true;
    122        
    123         rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
    124         if (rc != EOK)
    125                 goto error;
    126123       
    127124        printf("%s: Adding loopback device '%s'\n", NAME, dev->name);
    128125        return EOK;
    129 error:
    130         if (bound)
    131                 ddf_fun_unbind(fun);
    132         if (fun != NULL)
    133                 ddf_fun_destroy(fun);
    134        
    135         nic_unbind_and_destroy(dev);
    136         return rc;
    137126}
    138127

  • uspace/drv/nic/ne2k/dp8390.c

    r86c71de r47a89fe  
    5959#include <stdio.h>
    6060#include <libarch/ddi.h>
     61#include <net/packet.h>
     62#include <packet_client.h>
    6163#include "dp8390.h"
    6264
    … …  
    7476        uint8_t status;
    7577       
    76         /** Pointer to next frame */
     78        /** Pointer to next packet */
    7779        uint8_t next;
    7880       
    … …  
    391393        /*
    392394         * Reset the transmit ring. If we were transmitting a frame,
    393          * we pretend that the frame is processed. Higher layers will
    394          * retransmit if the frame wasn't actually sent.
     395         * we pretend that the packet is processed. Higher layers will
     396         * retransmit if the packet wasn't actually sent.
    395397         */
    396398        ne2k->sq.dirty = false;
    … …  
    446448                return NULL;
    447449       
    448         bzero(frame->data, length);
     450        void *buf = packet_suffix(frame->packet, length);
     451        bzero(buf, length);
    449452        uint8_t last = page + length / DP_PAGE;
    450453       
    … …  
    452455                size_t left = (ne2k->stop_page - page) * DP_PAGE
    453456                    - sizeof(recv_header_t);
    454                 ne2k_download(ne2k, frame->data, page * DP_PAGE + sizeof(recv_header_t),
     457                ne2k_download(ne2k, buf, page * DP_PAGE + sizeof(recv_header_t),
    455458                    left);
    456                 ne2k_download(ne2k, frame->data + left, ne2k->start_page * DP_PAGE,
     459                ne2k_download(ne2k, buf + left, ne2k->start_page * DP_PAGE,
    457460                    length - left);
    458461        } else {
    459                 ne2k_download(ne2k, frame->data, page * DP_PAGE + sizeof(recv_header_t),
     462                ne2k_download(ne2k, buf, page * DP_PAGE + sizeof(recv_header_t),
    460463                    length);
    461464        }
    … …  
    538541                 * Update the boundary pointer
    539542                 * to the value of the page
    540                  * prior to the next frame to
     543                 * prior to the next packet to
    541544                 * be processed.
    542545                 */
    … …  
    581584                fibril_mutex_lock(&ne2k->sq_mutex);
    582585                if (ne2k->sq.dirty) {
    583                         /* Prepare the buffer for next frame */
     586                        /* Prepare the buffer for next packet */
    584587                        ne2k->sq.dirty = false;
    585588                        ne2k->sq.size = 0;

  • uspace/drv/nic/ne2k/dp8390.h

    r86c71de r47a89fe  
    264264extern void ne2k_send(nic_t *, void *, size_t);
    265265extern void ne2k_interrupt(nic_t *, uint8_t, uint8_t);
     266extern packet_t *ne2k_alloc_packet(nic_t *, size_t);
    266267
    267268extern void ne2k_set_accept_mcast(ne2k_t *, int);

  • uspace/drv/nic/ne2k/ne2k.c

    r86c71de r47a89fe  
    261261        /* Note: some frame with previous physical address may slip to NIL here
    262262         * (for a moment the filtering is not exact), but ethernet should be OK with
    263          * that. Some frames may also be lost, but this is not a problem.
     263         * that. Some packet may also be lost, but this is not a problem.
    264264         */
    265265        ne2k_set_physical_address((ne2k_t *) nic_get_specific(nic_data), address);
    … …  
    338338static int ne2k_dev_add(ddf_dev_t *dev)
    339339{
    340         ddf_fun_t *fun;
    341        
    342340        /* Allocate driver data for the device. */
    343341        nic_t *nic_data = nic_create_and_bind(dev);
    … …  
    373371        }
    374372       
     373        rc = nic_register_as_ddf_fun(nic_data, &ne2k_dev_ops);
     374        if (rc != EOK) {
     375                ne2k_dev_cleanup(dev);
     376                return rc;
     377        }
     378       
    375379        rc = nic_connect_to_services(nic_data);
    376380        if (rc != EOK) {
    … …  
    379383        }
    380384       
    381         fun = ddf_fun_create(nic_get_ddf_dev(nic_data), fun_exposed, "port0");
    382         if (fun == NULL) {
    383                 ne2k_dev_cleanup(dev);
    384                 return ENOMEM;
    385         }
    386         nic_set_ddf_fun(nic_data, fun);
    387         fun->ops = &ne2k_dev_ops;
    388         fun->driver_data = nic_data;
    389        
    390         rc = ddf_fun_bind(fun);
    391         if (rc != EOK) {
    392                 ddf_fun_destroy(fun);
    393                 ne2k_dev_cleanup(dev);
    394                 return rc;
    395         }
    396        
    397         rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
    398         if (rc != EOK) {
    399                 ddf_fun_unbind(fun);
    400                 ddf_fun_destroy(fun);
    401                 return rc;
    402         }
    403        
    404385        return EOK;
    405386}

  • uspace/drv/nic/rtl8139/defs.h

    r86c71de r47a89fe  
    4242#define RTL8139_IO_SIZE 256
    4343
    44 /** The maximal transmitted frame length in bytes allowed according to RTL8139
     44/** The maximal transmitted packet length in bytes allowed according to RTL8139
    4545 *  documentation (see SIZE part of TSD documentation)
    4646 */
    47 #define RTL8139_FRAME_MAX_LENGTH 1792
     47#define RTL8139_PACKET_MAX_LENGTH 1792
    4848
    4949
    … …  
    9494
    9595        CR      = 0x37,  /**< Command register, 1b */
    96         CAPR    = 0x38,  /**< Current address of frame read, 2b */
     96        CAPR    = 0x38,  /**< Current address of packet read, 2b */
    9797        CBA     = 0x3a,  /**< Current buffer address, 2b */
    9898
    … …  
    282282        RCR_MulERINT = 1 << 17,    /**< Multiple early interrupt select */
    283283
    284         /** Minimal error frame length (1 = 8B, 0 = 64B). If AER/AR is set, RER8
     284        /** Minimal error packet length (1 = 8B, 0 = 64B). If AER/AR is set, RER8
    285285         * is "Don't care"
    286286         */
    … …  
    302302
    303303        RCR_WRAP              = 1 << 7,  /**< Rx buffer wrapped */
    304         RCR_ACCEPT_ERROR      = 1 << 5,  /**< Accept error frame */
    305         RCR_ACCEPT_RUNT       = 1 << 4,  /**< Accept Runt (8-64 bytes) frames */
     304        RCR_ACCEPT_ERROR      = 1 << 5,  /**< Accept error packet */
     305        RCR_ACCEPT_RUNT       = 1 << 4,  /**< Accept Runt (8-64 bytes) packets */
    306306        RCR_ACCEPT_BROADCAST  = 1 << 3,  /**< Accept broadcast */
    307307        RCR_ACCEPT_MULTICAST  = 1 << 2,  /**< Accept multicast */
    308308        RCR_ACCEPT_PHYS_MATCH = 1 << 1,  /**< Accept device MAC address match */
    309         RCR_ACCEPT_ALL_PHYS   = 1 << 0,  /**< Accept all frames with
     309        RCR_ACCEPT_ALL_PHYS   = 1 << 0,  /**< Accept all packets with
    310310                                          * phys. desticnation
    311311                                                                          */
    … …  
    362362        ANAR_ACK          = (1 << 14),  /**< Capability reception acknowledge */
    363363        ANAR_REMOTE_FAULT = (1 << 13),  /**< Remote fault detection capability */
    364         ANAR_PAUSE        = (1 << 10),  /**< Symetric pause frame capability */
     364        ANAR_PAUSE        = (1 << 10),  /**< Symetric pause packet capability */
    365365        ANAR_100T4        = (1 << 9),   /**< T4, not supported by the device */
    366366        ANAR_100TX_FD     = (1 << 8),   /**< 100BASE_TX full duplex */
    … …  
    399399        CONFIG3_GNT_SELECT = (1 << 7),  /**< Gnt select */
    400400        CONFIG3_PARM_EN    = (1 << 6),  /**< Parameter enabled (100MBit mode) */
    401         CONFIG3_MAGIC      = (1 << 5),  /**< WoL Magic frame enable */
     401        CONFIG3_MAGIC      = (1 << 5),  /**< WoL Magic packet enable */
    402402        CONFIG3_LINK_UP    = (1 << 4),  /**< Wakeup if link is reestablished */
    403403        CONFIG3_CLKRUN_EN  = (1 << 2),  /**< CLKRUN enabled */ /* TODO: check what does it mean */
    … …  
    416416};
    417417
    418 /** Maximal runt frame size + 1 */
     418/** Maximal runt packet size + 1 */
    419419#define RTL8139_RUNT_MAX_SIZE 64
    420420
    421 /** Bits in frame header */
    422 enum rtl8139_frame_header {
     421/** Bits in packet header */
     422enum rtl8139_packet_header {
    423423        RSR_MAR  = (1 << 15),  /**< Multicast received */
    424424        RSR_PAM  = (1 << 14),  /**< Physical address match */
    … …  
    426426
    427427        RSR_ISE  = (1 << 5),   /**< Invalid symbol error, 100BASE-TX only */
    428         RSR_RUNT = (1 << 4),   /**< Runt frame (< RTL8139_RUNT_MAX_SIZE bytes) */
    429 
    430         RSR_LONG = (1 << 3),   /**< Long frame (size > 4k bytes) */
     428        RSR_RUNT = (1 << 4),   /**< Runt packet (< RTL8139_RUNT_MAX_SIZE bytes) */
     429
     430        RSR_LONG = (1 << 3),   /**< Long packet (size > 4k bytes) */
    431431        RSR_CRC  = (1 << 2),   /**< CRC error */
    432432        RSR_FAE  = (1 << 1),   /**< Frame alignment error */
    433         RSR_ROK  = (1 << 0)    /**< Good frame received */
     433        RSR_ROK  = (1 << 0)    /**< Good packet received */
    434434};
    435435
    … …  
    451451                                                                          */
    452452
    453         APPEND_CRC = 1 << 16,        /**< Append CRC at the end of a frame */
     453        APPEND_CRC = 1 << 16,        /**< Append CRC at the end of a packet */
    454454
    455455        MXTxDMA_SHIFT = 8,  /**< Max. DMA Burst per TxDMA shift, burst = 16^value */
    … …  
    459459        TX_RETRY_COUNT_SIZE  = 4,            /**< Retries before aborting size */
    460460
    461         CLEAR_ABORT = 1 << 0    /**< Retransmit aborted frame at the last
     461        CLEAR_ABORT = 1 << 0    /**< Retransmit aborted packet at the last
    462462                                  *  transmitted descriptor
    463463                                                          */
    … …  
    478478extern const struct rtl8139_hwver_map rtl8139_versions[RTL8139_VER_COUNT + 1];
    479479
    480 /** Size in the frame header while copying from RxFIFO to Rx buffer */
     480/** Size in the packet header while copying from RxFIFO to Rx buffer */
    481481#define RTL8139_EARLY_SIZE UINT16_C(0xfff0)
    482 /** The only supported pause frame time value */
     482/** The only supported pause packet time value */
    483483#define RTL8139_PAUSE_VAL UINT16_C(0xFFFF)
    484484
    485 /** Size of the frame header in front of the received frame */
    486 #define RTL_FRAME_HEADER_SIZE 4
     485/** Size of the packet header in front of the received frame */
     486#define RTL_PACKET_HEADER_SIZE 4
    487487
    488488/** 8k buffer */

  • uspace/drv/nic/rtl8139/driver.c

    r86c71de r47a89fe  
    3939#include <io/log.h>
    4040#include <nic.h>
     41#include <packet_client.h>
    4142#include <device/pci.h>
    4243
    … …  
    151152}
    152153
    153 /** Update the mask of accepted frames in the RCR register according to
     154/** Update the mask of accepted packets in the RCR register according to
    154155 * rcr_accept_mode value in rtl8139_t
    155156 *
    … …  
    169170}
    170171
    171 /** Fill the mask of accepted multicast frames in the card registers
     172/** Fill the mask of accepted multicast packets in the card registers
    172173 *
    173174 *  @param rtl8139  The rtl8139 private data
    … …  
    393394#define rtl8139_tbuf_busy(tsd) ((pio_read_32(tsd) & TSD_OWN) == 0)
    394395
    395 /** Send frame with the hardware
     396/** Send packet with the hardware
    396397 *
    397398 * note: the main_lock is locked when framework calls this function
    … …  
    411412        ddf_msg(LVL_DEBUG, "Sending frame");
    412413
    413         if (size > RTL8139_FRAME_MAX_LENGTH) {
     414        if (size > RTL8139_PACKET_MAX_LENGTH) {
    414415                ddf_msg(LVL_ERROR, "Send frame: frame too long, %zu bytes",
    415416                    size);
    … …  
    436437        fibril_mutex_unlock(&rtl8139->tx_lock);
    437438
    438         /* Get address of the buffer descriptor and frame data */
     439        /* Get address of the buffer descriptor and packet data */
    439440        void *tsd = rtl8139->io_port + TSD0 + tx_curr * 4;
    440441        void *buf_addr = rtl8139->tx_buff[tx_curr];
    … …  
    504505}
    505506
    506 /** Create frame structure from the buffer data
     507/** Create packet structure from the buffer data
    507508 *
    508509 * @param nic_data      NIC driver data
    509510 * @param rx_buffer     The receiver buffer
    510511 * @param rx_size       The buffer size
    511  * @param frame_start   The offset where packet data start
    512  * @param frame_size    The size of the frame data
    513  *
    514  * @return The frame list node (not connected)
    515  */
    516 static nic_frame_t *rtl8139_read_frame(nic_t *nic_data,
    517     void *rx_buffer, size_t rx_size, size_t frame_start, size_t frame_size)
    518 {
    519         nic_frame_t *frame = nic_alloc_frame(nic_data, frame_size);
     512 * @param packet_start  The offset where packet data start
     513 * @param packet_size   The size of the packet data
     514 *
     515 * @return The packet  list node (not connected)
     516 */
     517static nic_frame_t *rtl8139_read_packet(nic_t *nic_data,
     518    void *rx_buffer, size_t rx_size, size_t packet_start, size_t packet_size)
     519{
     520        nic_frame_t *frame = nic_alloc_frame(nic_data, packet_size);
    520521        if (! frame) {
    521                 ddf_msg(LVL_ERROR, "Can not allocate frame for received frame.");
     522                ddf_msg(LVL_ERROR, "Can not allocate frame for received packet.");
    522523                return NULL;
    523524        }
    524525
    525         void *ret = rtl8139_memcpy_wrapped(frame->data, rx_buffer, frame_start,
    526             RxBUF_SIZE, frame_size);
     526        void *packet_data = packet_suffix(frame->packet, packet_size);
     527        if (!packet_data) {
     528                ddf_msg(LVL_ERROR, "Can not get the packet suffix.");
     529                nic_release_frame(nic_data, frame);
     530                return NULL;
     531        }
     532
     533        void *ret = rtl8139_memcpy_wrapped(packet_data, rx_buffer, packet_start,
     534            RxBUF_SIZE, packet_size);
    527535        if (ret == NULL) {
    528536                nic_release_frame(nic_data, frame);
    … …  
    560568}
    561569
    562 /** Receive all frames in queue
     570/** Receive all packets in queue
    563571 *
    564572 *  @param nic_data  The controller data
    565  *  @return The linked list of nic_frame_list_t nodes, each containing one frame
    566  */
    567 static nic_frame_list_t *rtl8139_frame_receive(nic_t *nic_data)
     573 *  @return The linked list of packet_list_t nodes, each containing one packet
     574 */
     575static nic_frame_list_t *rtl8139_packet_receive(nic_t *nic_data)
    568576{
    569577        rtl8139_t *rtl8139 = nic_get_specific(nic_data);
    … …  
    573581        nic_frame_list_t *frames = nic_alloc_frame_list();
    574582        if (!frames)
    575                 ddf_msg(LVL_ERROR, "Can not allocate frame list for received frames.");
     583                ddf_msg(LVL_ERROR, "Can not allocate frame list for received packets.");
    576584
    577585        void *rx_buffer = rtl8139->rx_buff_virt;
    … …  
    597605        while (!rtl8139_hw_buffer_empty(rtl8139)) {
    598606                void *rx_ptr = rx_buffer + rx_offset % RxBUF_SIZE;
    599                 uint32_t frame_header = uint32_t_le2host( *((uint32_t*)rx_ptr) );
    600                 uint16_t size = frame_header >> 16;
    601                 uint16_t frame_size = size - RTL8139_CRC_SIZE;
    602                 /* received frame flags in frame header */
    603                 uint16_t rcs = (uint16_t) frame_header;
     607                uint32_t packet_header = uint32_t_le2host( *((uint32_t*)rx_ptr) );
     608                uint16_t size = packet_header >> 16;
     609                uint16_t packet_size = size - RTL8139_CRC_SIZE;
     610                /* received packet flags in packet header */
     611                uint16_t rcs = (uint16_t) packet_header;
    604612
    605613                if (size == RTL8139_EARLY_SIZE) {
    606                         /* The frame copying is still in progress, break receiving */
     614                        /* The packet copying is still in progress, break receiving */
    607615                        ddf_msg(LVL_DEBUG, "Early threshold reached, not completely coppied");
    608616                        break;
    … …  
    610618
    611619                /* Check if the header is valid, otherwise we are lost in the buffer */
    612                 if (size == 0 || size > RTL8139_FRAME_MAX_LENGTH) {
     620                if (size == 0 || size > RTL8139_PACKET_MAX_LENGTH) {
    613621                        ddf_msg(LVL_ERROR, "Receiver error -> receiver reset (size: %4"PRIu16", "
    614                             "header 0x%4"PRIx16". Offset: %zu)", size, frame_header,
     622                            "header 0x%4"PRIx16". Offset: %zu)", size, packet_header,
    615623                            rx_offset);
    616624                        goto rx_err;
    … …  
    621629                }
    622630
    623                 cur_read += size + RTL_FRAME_HEADER_SIZE;
     631                cur_read += size + RTL_PACKET_HEADER_SIZE;
    624632                if (cur_read > max_read)
    625633                        break;
    626634
    627635                if (frames) {
    628                         nic_frame_t *frame = rtl8139_read_frame(nic_data, rx_buffer,
    629                             RxBUF_SIZE, rx_offset + RTL_FRAME_HEADER_SIZE, frame_size);
     636                        nic_frame_t *frame = rtl8139_read_packet(nic_data, rx_buffer,
     637                            RxBUF_SIZE, rx_offset + RTL_PACKET_HEADER_SIZE, packet_size);
    630638
    631639                        if (frame)
    … …  
    634642
    635643                /* Update offset */
    636                 rx_offset = ALIGN_UP(rx_offset + size + RTL_FRAME_HEADER_SIZE, 4);
    637 
    638                 /* Write lesser value to prevent overflow into unread frame
     644                rx_offset = ALIGN_UP(rx_offset + size + RTL_PACKET_HEADER_SIZE, 4);
     645
     646                /* Write lesser value to prevent overflow into unread packet
    639647                 * (the recomendation from the RealTech rtl8139 programming guide)
    640648                 */
    … …  
    719727                tx_used++;
    720728
    721                 /* If the frame was sent */
     729                /* If the packet was sent */
    722730                if (tsd_value & TSD_TOK) {
    723731                        size_t size = REG_GET_VAL(tsd_value, TSD_SIZE);
    … …  
    749757}
    750758
    751 /** Receive all frames from the buffer
     759/** Receive all packets from the buffer
    752760 *
    753761 *  @param rtl8139  driver private data
    754762 */
    755 static void rtl8139_receive_frames(nic_t *nic_data)
     763static void rtl8139_receive_packets(nic_t *nic_data)
    756764{
    757765        assert(nic_data);
    … …  
    761769
    762770        fibril_mutex_lock(&rtl8139->rx_lock);
    763         nic_frame_list_t *frames = rtl8139_frame_receive(nic_data);
     771        nic_frame_list_t *frames = rtl8139_packet_receive(nic_data);
    764772        fibril_mutex_unlock(&rtl8139->rx_lock);
    765773
    … …  
    817825        }
    818826
    819         /* Check transmittion interrupts first to allow transmit next frames
     827        /* Check transmittion interrupts first to allow transmit next packets
    820828         * sooner
    821829         */
    … …  
    824832        }
    825833        if (isr & INT_ROK) {
    826                 rtl8139_receive_frames(nic_data);
     834                rtl8139_receive_packets(nic_data);
    827835        }
    828836        if (isr & (INT_RER | INT_RXOVW | INT_FIFOOVW)) {
    … …  
    925933}
    926934
    927 /** Activate the device to receive and transmit frames
     935/** Activate the device to receive and transmit packets
    928936 *
    929937 *  @param nic_data  The nic driver data
    … …  
    12051213                goto failed;
    12061214
    1207         /* Set default frame acceptance */
     1215        /* Set default packet acceptance */
    12081216        rtl8139->rcr_data.ucast_mask = RTL8139_RCR_UCAST_DEFAULT;
    12091217        rtl8139->rcr_data.mcast_mask = RTL8139_RCR_MCAST_DEFAULT;
    12101218        rtl8139->rcr_data.bcast_mask = RTL8139_RCR_BCAST_DEFAULT;
    12111219        rtl8139->rcr_data.defect_mask = RTL8139_RCR_DEFECT_DEFAULT;
    1212         /* Set receiver early treshold to 8/16 of frame length */
     1220        /* Set receiver early treshold to 8/16 of packet length */
    12131221        rtl8139->rcr_data.rcr_base = (0x8 << RCR_ERTH_SHIFT);
    12141222
    … …  
    12801288int rtl8139_dev_add(ddf_dev_t *dev)
    12811289{
    1282         ddf_fun_t *fun;
    1283 
    12841290        assert(dev);
    12851291        ddf_msg(LVL_NOTE, "RTL8139_dev_add %s (handle = %d)", dev->name, dev->handle);
    … …  
    13181324        }
    13191325
    1320         fun = ddf_fun_create(nic_get_ddf_dev(nic_data), fun_exposed, "port0");
    1321         if (fun == NULL) {
    1322                 ddf_msg(LVL_ERROR, "Failed creating device function");
    1323                 goto err_srv;
    1324         }
    1325         nic_set_ddf_fun(nic_data, fun);
    1326         fun->ops = &rtl8139_dev_ops;
    1327         fun->driver_data = nic_data;
    1328 
    1329         rc = ddf_fun_bind(fun);
     1326        rc = nic_register_as_ddf_fun(nic_data, &rtl8139_dev_ops);
    13301327        if (rc != EOK) {
    1331                 ddf_msg(LVL_ERROR, "Failed binding device function");
    1332                 goto err_fun_create;
    1333         }
    1334         rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
    1335         if (rc != EOK) {
    1336                 ddf_msg(LVL_ERROR, "Failed adding function to category");
    1337                 goto err_fun_bind;
     1328                ddf_msg(LVL_ERROR, "Failed to register as DDF function - error %d", rc);
     1329                goto err_irq;
    13381330        }
    13391331
    … …  
    13431335        return EOK;
    13441336
    1345 err_fun_bind:
    1346         ddf_fun_unbind(fun);
    1347 err_fun_create:
    1348         ddf_fun_destroy(fun);
    1349 err_srv:
    1350         /* XXX Disconnect from services */
    13511337err_irq:
    13521338        unregister_interrupt_handler(dev, rtl8139->irq);
    … …  
    14911477};
    14921478
    1493 /** Check if pause frame operations are valid in current situation
     1479/** Check if pause packet operations are valid in current situation
    14941480 *
    14951481 *  @param rtl8139  RTL8139 private structure
    … …  
    15161502}
    15171503
    1518 /** Get current pause frame configuration
     1504/** Get current pause packet configuration
    15191505 *
    15201506 *  Values are filled with NIC_RESULT_NOT_AVAILABLE if the value has no sense in
    … …  
    15221508 *
    15231509 *  @param[in]  fun         The DDF structure of the RTL8139
    1524  *  @param[out] we_send     Sign if local constroller sends pause frame
    1525  *  @param[out] we_receive  Sign if local constroller receives pause frame
    1526  *  @param[out] time        Time filled in pause frames. 0xFFFF in rtl8139
     1510 *  @param[out] we_send     Sign if local constroller sends pause packets
     1511 *  @param[out] we_receive  Sign if local constroller receives pause packets
     1512 *  @param[out] time        Time filled in pause packets. 0xFFFF in rtl8139
    15271513 *
    15281514 *  @return EOK if succeed
    … …  
    15541540};
    15551541
    1556 /** Set current pause frame configuration
     1542/** Set current pause packet configuration
    15571543 *
    15581544 *  @param fun            The DDF structure of the RTL8139
    1559  *  @param allow_send     Sign if local constroller sends pause frame
    1560  *  @param allow_receive  Sign if local constroller receives pause frames
     1545 *  @param allow_send     Sign if local constroller sends pause packets
     1546 *  @param allow_receive  Sign if local constroller receives pause packets
    15611547 *  @param time           Time to use, ignored (not supported by device)
    15621548 *
    1563  *  @return EOK if succeed, INVAL if the pause frame has no sence
     1549 *  @return EOK if succeed, INVAL if the pause packet has no sence
    15641550 */
    15651551static int rtl8139_pause_set(ddf_fun_t *fun, int allow_send, int allow_receive,
    … …  
    18101796}
    18111797
    1812 /** Set unicast frames acceptance mode
     1798/** Set unicast packets acceptance mode
    18131799 *
    18141800 *  @param nic_data  The nic device to update
    … …  
    18681854}
    18691855
    1870 /** Set multicast frames acceptance mode
     1856/** Set multicast packets acceptance mode
    18711857 *
    18721858 *  @param nic_data  The nic device to update
    … …  
    19131899}
    19141900
    1915 /** Set broadcast frames acceptance mode
     1901/** Set broadcast packets acceptance mode
    19161902 *
    19171903 *  @param nic_data  The nic device to update
    … …  
    19431929}
    19441930
    1945 /** Get state of acceptance of weird frames
     1931/** Get state of acceptance of weird packets
    19461932 *
    19471933 *  @param[in]  device  The device to check
    … …  
    19651951};
    19661952
    1967 /** Set acceptance of weird frames
     1953/** Set acceptance of weird packets
    19681954 *
    19691955 *  @param device  The device to update
    … …  
    21412127}
    21422128
    2143 /** Force receiving all frames in the receive buffer
     2129/** Force receiving all packets in the receive buffer
    21442130 *
    21452131 *  @param device  The device to receive

  • uspace/drv/nic/rtl8139/driver.h

    r86c71de r47a89fe  
    3939/** Transmittion buffers count */
    4040#define TX_BUFF_COUNT 4
    41 /** Size of buffer for one frame
     41/** Size of buffer for one packet
    4242 *  - 2kB
    4343 */
    … …  
    4949#define RTL8139_CRC_SIZE 4
    5050
    51 /** The default mode of accepting unicast frames */
     51/** The default mode of accepting unicast packets */
    5252#define RTL8139_RCR_UCAST_DEFAULT RCR_ACCEPT_PHYS_MATCH
    53 /** The default mode of accepting multicast frames */
     53/** The default mode of accepting multicast packets */
    5454#define RTL8139_RCR_MCAST_DEFAULT 0
    55 /** The default mode of accepting broadcast frames */
     55/** The default mode of accepting broadcast packets */
    5656#define RTL8139_RCR_BCAST_DEFAULT RCR_ACCEPT_BROADCAST
    57 /** The default mode of accepting defect frames */
     57/** The default mode of accepting defect packets */
    5858#define RTL8139_RCR_DEFECT_DEFAULT 0
    5959
    … …  
    112112        size_t tx_used;
    113113
    114         /** Buffer for receiving frames */
     114        /** Buffer for receiving packets */
    115115        void *rx_buff_phys;
    116116        void *rx_buff_virt;

  • uspace/lib/net/include/nil_remote.h

    r86c71de r47a89fe  
    3939#include <generic.h>
    4040#include <async.h>
    41 #include <sys/types.h>
    4241
    4342#define nil_bind_service(service, device_id, me, receiver) \
    … …  
    6261    size_t);
    6362extern int nil_device_state_msg(async_sess_t *, nic_device_id_t, sysarg_t);
    64 extern int nil_received_msg(async_sess_t *, nic_device_id_t, void *, size_t);
     63extern int nil_received_msg(async_sess_t *, nic_device_id_t, packet_id_t);
    6564extern int nil_addr_changed_msg(async_sess_t *, nic_device_id_t,
    6665    const nic_address_t *);

  • uspace/lib/net/nil/nil_remote.c

    r86c71de r47a89fe  
    7777 */
    7878int nil_received_msg(async_sess_t *sess, nic_device_id_t device_id,
    79     void *data, size_t size)
     79    packet_id_t packet_id)
    8080{
    81         async_exch_t *exch = async_exchange_begin(sess);
    82 
    83         ipc_call_t answer;
    84         aid_t req = async_send_1(exch, NET_NIL_RECEIVED, (sysarg_t) device_id,
    85             &answer);
    86         sysarg_t retval = async_data_write_start(exch, data, size);
    87 
    88         async_exchange_end(exch);
    89 
    90         if (retval != EOK) {
    91                 async_wait_for(req, NULL);
    92                 return retval;
    93         }
    94 
    95         async_wait_for(req, &retval);
    96         return retval;
     81        return generic_received_msg_remote(sess, NET_NIL_RECEIVED,
     82            device_id, packet_id, 0, 0);
    9783}
    9884

  • uspace/lib/nic/include/nic.h

    r86c71de r47a89fe  
    4242#include <ddf/driver.h>
    4343#include <device/hw_res_parsed.h>
     44#include <net/packet.h>
    4445#include <ops/nic.h>
    45 
    46 #define DEVICE_CATEGORY_NIC "nic"
    4746
    4847struct nic;
    … …  
    6261
    6362/**
    64  * Simple structure for sending lists of frames.
     63 * Simple structure for sending the allocated frames (packets) in a list.
    6564 */
    6665typedef struct {
    6766        link_t link;
    68         void *data;
    69         size_t size;
     67        packet_t *packet;
    7068} nic_frame_t;
    7169
    … …  
    7371
    7472/**
    75  * Handler for writing frame data to the NIC device.
    76  * The function is responsible for releasing the frame.
     73 * Handler for writing packet data to the NIC device.
     74 * The function is responsible for releasing the packet.
    7775 * It does not return anything, if some error is detected the function just
    7876 * silently fails (logging on debug level is suggested).
    … …  
    160158 * @return ENOTSUP      If this filter cannot work on this NIC (e.g. the NIC
    161159 *                                      cannot run in promiscuous node or the limit of WOL
    162  *                                      frames' specifications was reached).
     160 *                                      packets' specifications was reached).
    163161 * @return ELIMIT       If this filter must implemented in HW but currently the
    164162 *                                      limit of these HW filters was reached.
    … …  
    206204/* Functions called in add_device */
    207205extern int nic_connect_to_services(nic_t *);
     206extern int nic_register_as_ddf_fun(nic_t *, ddf_dev_ops_t *);
    208207extern int nic_get_resources(nic_t *, hw_res_list_parsed_t *);
    209208extern void nic_set_specific(nic_t *, void *);
    … …  
    226225extern ddf_dev_t *nic_get_ddf_dev(nic_t *);
    227226extern ddf_fun_t *nic_get_ddf_fun(nic_t *);
    228 extern void nic_set_ddf_fun(nic_t *, ddf_fun_t *);
    229227extern nic_t *nic_get_from_ddf_dev(ddf_dev_t *);
    230228extern nic_t *nic_get_from_ddf_fun(ddf_fun_t *);
    … …  
    235233extern int nic_report_poll_mode(nic_t *, nic_poll_mode_t, struct timeval *);
    236234extern void nic_query_address(nic_t *, nic_address_t *);
    237 extern void nic_received_noneth_frame(nic_t *, void *, size_t);
     235extern void nic_received_packet(nic_t *, packet_t *);
     236extern void nic_received_noneth_packet(nic_t *, packet_t *);
    238237extern void nic_received_frame(nic_t *, nic_frame_t *);
    239238extern void nic_received_frame_list(nic_t *, nic_frame_list_t *);
    … …  
    249248extern void nic_report_collisions(nic_t *, unsigned);
    250249
    251 /* Frame / frame list allocation and deallocation */
     250/* Packet / frame / frame list allocation and deallocation */
     251extern packet_t *nic_alloc_packet(nic_t *, size_t);
     252extern void nic_release_packet(nic_t *, packet_t *);
    252253extern nic_frame_t *nic_alloc_frame(nic_t *, size_t);
    253254extern nic_frame_list_t *nic_alloc_frame_list(void);
    … …  
    274275extern void nic_sw_period_stop(nic_t *);
    275276
     277/* Packet DMA lock */
     278extern int nic_dma_lock_packet(packet_t *, size_t, void **);
     279extern int nic_dma_unlock_packet(packet_t *, size_t);
     280
    276281#endif // __NIC_H__
    277282

  • uspace/lib/nic/include/nic_driver.h

    r86c71de r47a89fe  
    5050#include "nic_rx_control.h"
    5151#include "nic_wol_virtues.h"
     52
     53#define DEVICE_CATEGORY_NIC "nic"
    5254
    5355struct sw_poll_info {

  • uspace/lib/nic/include/nic_rx_control.h

    r86c71de r47a89fe  
    4646#include <fibril_synch.h>
    4747#include <net/device.h>
     48#include <net/packet_header.h>
    4849
    4950#include "nic_addr_db.h"
    … …  
    119120        const nic_address_t *prev_addr, const nic_address_t *curr_addr);
    120121extern int nic_rxc_check(const nic_rxc_t *rxc,
    121         const void *data, size_t size, nic_frame_type_t *frame_type);
     122        const packet_t *packet, nic_frame_type_t *frame_type);
    122123extern void nic_rxc_hw_filtering(nic_rxc_t *rxc,
    123124        int unicast_exact, int multicast_exact, int vlan_exact);

  • uspace/lib/nic/src/nic_driver.c

    r86c71de r47a89fe  
    5151#include <net_interface.h>
    5252#include <ops/nic.h>
     53#include <packet_client.h>
     54#include <packet_remote.h>
     55#include <net/packet_header.h>
    5356#include <errno.h>
    5457
    … …  
    6164
    6265/**
    63  * Initializes libraries required for NIC framework - logger
     66 * Initializes libraries required for NIC framework - logger, packet manager
    6467 *
    6568 * @param name  Name of the device/driver (used in logging)
    … …  
    7679        snprintf(buffer, 256, "drv/" DEVICE_CATEGORY_NIC "/%s", name);
    7780       
    78         return EOK;
     81        /* Initialize packet manager */
     82        return pm_init();
    7983}
    8084
    … …  
    158162
    159163/**
    160  * Setup send frame handler. This MUST be called in the add_device handler
     164 * Setup write packet handler. This MUST be called in the add_device handler
    161165 * if the nic_send_message_impl function is used for sending messages (filled
    162166 * as send_message member of the nic_iface_t structure). The function must not
    … …  
    266270}
    267271
    268 /** Allocate frame
     272/**
     273 * Just a wrapper over the packet_get_1_remote function
     274 */
     275packet_t *nic_alloc_packet(nic_t *nic_data, size_t data_size)
     276{
     277        return packet_get_1_remote(nic_data->net_session, data_size);
     278}
     279
     280
     281/**
     282 * Just a wrapper over the pq_release_remote function
     283 */
     284void nic_release_packet(nic_t *nic_data, packet_t *packet)
     285{
     286        pq_release_remote(nic_data->net_session, packet_get_id(packet));
     287}
     288
     289/** Allocate frame and packet
    269290 *
    270291 *  @param nic_data     The NIC driver data
    271  *  @param size         Frame size in bytes
     292 *  @param packet_size  Size of packet
     293 *  @param offload_size Size of packet offload
    272294 *  @return pointer to allocated frame if success, NULL otherwise
    273295 */
    274 nic_frame_t *nic_alloc_frame(nic_t *nic_data, size_t size)
     296nic_frame_t *nic_alloc_frame(nic_t *nic_data, size_t packet_size)
    275297{
    276298        nic_frame_t *frame;
    … …  
    291313        }
    292314
    293         frame->data = malloc(size);
    294         if (frame->data == NULL) {
     315        packet_t *packet = nic_alloc_packet(nic_data, packet_size);
     316        if (!packet) {
    295317                free(frame);
    296318                return NULL;
    297319        }
    298320
    299         frame->size = size;
     321        frame->packet = packet;
    300322        return frame;
    301323}
    … …  
    310332        if (!frame)
    311333                return;
    312 
    313         if (frame->data != NULL) {
    314                 free(frame->data);
    315                 frame->data = NULL;
    316                 frame->size = 0;
    317         }
    318 
     334        if (frame->packet != NULL) {
     335                nic_release_packet(nic_data, frame->packet);
     336        }
    319337        fibril_mutex_lock(&nic_globals.lock);
    320338        if (nic_globals.frame_cache_size >= NIC_GLOBALS_MAX_CACHE_SIZE) {
    … …  
    586604
    587605/**
    588  * The busy flag can be set to 1 only in the send_frame handler, to 0 it can
     606 * The busy flag can be set to 1 only in the write_packet handler, to 0 it can
    589607 * be set anywhere.
    590608 *
    … …  
    595613{
    596614        /*
    597          * When the function is called in send_frame handler the main lock is
     615         * When the function is called in write_packet handler the main lock is
    598616         * locked so no race can happen.
    599617         * Otherwise, when it is unexpectedly set to 0 (even with main lock held
    … …  
    604622
    605623/**
    606  * This is the function that the driver should call when it receives a frame.
    607  * The frame is checked by filters and then sent up to the NIL layer or
    608  * discarded. The frame is released.
    609  *
    610  * @param nic_data
    611  * @param frame         The received frame
     624 * Provided for correct naming conventions.
     625 * The packet is checked by filters and then sent up to the NIL layer or
     626 * discarded, the frame is released.
     627 *
     628 * @param nic_data
     629 * @param frame         The frame containing received packet
    612630 */
    613631void nic_received_frame(nic_t *nic_data, nic_frame_t *frame)
    614632{
     633        nic_received_packet(nic_data, frame->packet);
     634        frame->packet = NULL;
     635        nic_release_frame(nic_data, frame);
     636}
     637
     638/**
     639 * This is the function that the driver should call when it receives a packet.
     640 * The packet is checked by filters and then sent up to the NIL layer or
     641 * discarded.
     642 *
     643 * @param nic_data
     644 * @param packet                The received packet
     645 */
     646void nic_received_packet(nic_t *nic_data, packet_t *packet)
     647{
    615648        /* Note: this function must not lock main lock, because loopback driver
    616          *               calls it inside send_frame handler (with locked main lock) */
     649         *               calls it inside write_packet handler (with locked main lock) */
     650        packet_id_t pid = packet_get_id(packet);
     651       
    617652        fibril_rwlock_read_lock(&nic_data->rxc_lock);
    618653        nic_frame_type_t frame_type;
    619         int check = nic_rxc_check(&nic_data->rx_control, frame->data,
    620             frame->size, &frame_type);
     654        int check = nic_rxc_check(&nic_data->rx_control, packet, &frame_type);
    621655        fibril_rwlock_read_unlock(&nic_data->rxc_lock);
    622656        /* Update statistics */
    623657        fibril_rwlock_write_lock(&nic_data->stats_lock);
    624 
     658        /* Both sending message up and releasing packet are atomic IPC calls */
    625659        if (nic_data->state == NIC_STATE_ACTIVE && check) {
    626660                nic_data->stats.receive_packets++;
    627                 nic_data->stats.receive_bytes += frame->size;
     661                nic_data->stats.receive_bytes += packet_get_data_length(packet);
    628662                switch (frame_type) {
    629663                case NIC_FRAME_MULTICAST:
    … …  
    637671                }
    638672                fibril_rwlock_write_unlock(&nic_data->stats_lock);
    639                 nil_received_msg(nic_data->nil_session, nic_data->device_id,
    640                     frame->data, frame->size);
     673                nil_received_msg(nic_data->nil_session, nic_data->device_id, pid);
    641674        } else {
    642675                switch (frame_type) {
    … …  
    652685                }
    653686                fibril_rwlock_write_unlock(&nic_data->stats_lock);
    654         }
    655         nic_release_frame(nic_data, frame);
     687                nic_release_packet(nic_data, packet);
     688        }
    656689}
    657690
    658691/**
    659692 * This function is to be used only in the loopback driver. It's workaround
    660  * for the situation when the frame does not contain ethernet address.
     693 * for the situation when the packet does not contain ethernet address.
    661694 * The filtering is therefore not applied here.
    662695 *
    663696 * @param nic_data
    664  * @param data          Frame data
    665  * @param size          Frame size in bytes
    666  */
    667 void nic_received_noneth_frame(nic_t *nic_data, void *data, size_t size)
     697 * @param packet
     698 */
     699void nic_received_noneth_packet(nic_t *nic_data, packet_t *packet)
    668700{
    669701        fibril_rwlock_write_lock(&nic_data->stats_lock);
    670702        nic_data->stats.receive_packets++;
    671         nic_data->stats.receive_bytes += size;
     703        nic_data->stats.receive_bytes += packet_get_data_length(packet);
    672704        fibril_rwlock_write_unlock(&nic_data->stats_lock);
    673705       
    674706        nil_received_msg(nic_data->nil_session, nic_data->device_id,
    675             data, size);
    676 }
    677 
    678 /**
    679  * Some NICs can receive multiple frames during single interrupt. These can
     707            packet_get_id(packet));
     708}
     709
     710/**
     711 * Some NICs can receive multiple packets during single interrupt. These can
    680712 * send them in whole list of frames (actually nic_frame_t structures), then
    681  * the list is deallocated and each frame is passed to the
     713 * the list is deallocated and each packet is passed to the
    682714 * nic_received_packet function.
    683715 *
    … …  
    694726
    695727                list_remove(&frame->link);
    696                 nic_received_frame(nic_data, frame);
     728                nic_received_packet(nic_data, frame->packet);
     729                frame->packet = NULL;
     730                nic_release_frame(nic_data, frame);
    697731        }
    698732        nic_driver_release_frame_list(frames);
    … …  
    812846
    813847/**
     848 * Creates an exposed DDF function for the device, named "port0".
     849 * Device options are set as this function's options. The function is bound
     850 * (see ddf_fun_bind) and then registered to the DEVICE_CATEGORY_NIC class.
     851 * Note: this function should be called only from add_device handler, therefore
     852 * we don't need to use locks.
     853 *
     854 * @param nic_data      The NIC structure
     855 * @param ops           Device options for the DDF function.
     856 */
     857int nic_register_as_ddf_fun(nic_t *nic_data, ddf_dev_ops_t *ops)
     858{
     859        int rc;
     860        assert(nic_data);
     861
     862        nic_data->fun = ddf_fun_create(nic_data->dev, fun_exposed, "port0");
     863        if (nic_data->fun == NULL)
     864                return ENOMEM;
     865       
     866        nic_data->fun->ops = ops;
     867        nic_data->fun->driver_data = nic_data;
     868
     869        rc = ddf_fun_bind(nic_data->fun);
     870        if (rc != EOK) {
     871                ddf_fun_destroy(nic_data->fun);
     872                return rc;
     873        }
     874
     875        rc = ddf_fun_add_to_category(nic_data->fun, DEVICE_CATEGORY_NIC);
     876        if (rc != EOK) {
     877                ddf_fun_destroy(nic_data->fun);
     878                return rc;
     879        }
     880       
     881        return EOK;
     882}
     883
     884/**
    814885 * Set information about current HW filtering.
    815886 *  1 ...       Only those frames we want to receive are passed through HW
    … …  
    10261097{
    10271098        return nic_data->fun;
    1028 }
    1029 
    1030 /**
    1031  * @param nic_data
    1032  * @param fun
    1033  */
    1034 void nic_set_ddf_fun(nic_t *nic_data, ddf_fun_t *fun)
    1035 {
    1036         nic_data->fun = fun;
    10371099}
    10381100
    … …  
    12671329}
    12681330
     1331/** Lock packet for DMA usage
     1332 *
     1333 * @param packet
     1334 * @return physical address of packet
     1335 */
     1336int nic_dma_lock_packet(packet_t *packet, size_t size, void **phys)
     1337{
     1338        return dmamem_map(packet, SIZE2PAGES(size), 0, 0, phys);
     1339}
     1340
     1341/** Unlock packet after DMA usage
     1342 *
     1343 * @param packet
     1344 */
     1345int nic_dma_unlock_packet(packet_t *packet, size_t size)
     1346{
     1347        return dmamem_unmap(packet, size);
     1348}
     1349
    12691350/** @}
    12701351 */

  • uspace/lib/nic/src/nic_rx_control.c

    r86c71de r47a89fe  
    392392 *
    393393 * @param rxc
    394  * @param frame     The probed frame
     394 * @param packet        The probed frame
    395395 *
    396396 * @return True if the frame passes, false if it does not
    397397 */
    398 int nic_rxc_check(const nic_rxc_t *rxc, const void *data, size_t size,
     398int nic_rxc_check(const nic_rxc_t *rxc, const packet_t *packet,
    399399        nic_frame_type_t *frame_type)
    400400{
    401401        assert(frame_type != NULL);
    402         uint8_t *dest_addr = (uint8_t *) data;
     402        uint8_t *dest_addr = (uint8_t *) packet + packet->data_start;
    403403        uint8_t *src_addr = dest_addr + ETH_ADDR;
    404 
    405         if (size < 2 * ETH_ADDR)
    406                 return false;
    407404
    408405        if (dest_addr[0] & 1) {
    … …  
    451448        if (!rxc->vlan_exact && rxc->vlan_mask != NULL) {
    452449                vlan_header_t *vlan_header = (vlan_header_t *)
    453                         ((uint8_t *) data + 2 * ETH_ADDR);
     450                        ((uint8_t *) packet + packet->data_start + 2 * ETH_ADDR);
    454451                if (vlan_header->tpid_upper == VLAN_TPID_UPPER &&
    455452                        vlan_header->tpid_lower == VLAN_TPID_LOWER) {

  • uspace/srv/net/nil/eth/eth.c

    r86c71de r47a89fe  
    814814}
    815815
    816 static int eth_received(nic_device_id_t device_id)
    817 {
    818         void *data;
    819         size_t size;
    820         int rc;
    821        
    822         rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    823         if (rc != EOK)
    824                 return rc;
    825        
    826         packet_t *packet = packet_get_1_remote(eth_globals.net_sess, size);
    827         if (packet == NULL)
    828                 return ENOMEM;
    829        
    830         void *pdata = packet_suffix(packet, size);
    831         memcpy(pdata, data, size);
    832         free(data);
    833        
    834         return nil_received_msg_local(device_id, packet);
    835 }
    836 
    837816static int eth_addr_changed(nic_device_id_t device_id)
    838817{
    … …  
    947926                return EOK;
    948927        case NET_NIL_RECEIVED:
    949                 rc = eth_received(IPC_GET_ARG1(*call));
     928                rc = packet_translate_remote(eth_globals.net_sess, &packet,
     929                    IPC_GET_ARG2(*call));
     930                if (rc == EOK)
     931                        rc = nil_received_msg_local(IPC_GET_ARG1(*call), packet);
     932               
    950933                async_answer_0(callid, (sysarg_t) rc);
    951934                return rc;

  • uspace/srv/net/nil/nildummy/nildummy.c

    r86c71de r47a89fe  
    370370}
    371371
    372 static int nildummy_received(nic_device_id_t device_id)
    373 {
    374         void *data;
    375         size_t size;
    376         int rc;
    377 
    378         rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    379         if (rc != EOK)
    380                 return rc;
    381 
    382         packet_t *packet = packet_get_1_remote(nildummy_globals.net_sess, size);
    383         if (packet == NULL)
    384                 return ENOMEM;
    385 
    386         void *pdata = packet_suffix(packet, size);
    387         memcpy(pdata, data, size);
    388         free(pdata);
    389 
    390         return nil_received_msg_local(device_id, packet);
    391 }
    392 
    393372int nil_module_message(ipc_callid_t callid, ipc_call_t *call,
    394373    ipc_call_t *answer, size_t *answer_count)
    … …  
    452431       
    453432        case NET_NIL_RECEIVED:
    454                 rc = nildummy_received(IPC_GET_ARG1(*call));
     433                rc = packet_translate_remote(nildummy_globals.net_sess, &packet,
     434                    IPC_GET_ARG2(*call));
     435                if (rc == EOK)
     436                        rc = nil_received_msg_local(IPC_GET_ARG1(*call), packet);
     437               
    455438                async_answer_0(callid, (sysarg_t) rc);
    456439                return rc;
Note: See TracChangeset for help on using the changeset viewer.