Changeset 49ff5f3 in mainline for uspace/drv/nic


Ignore:
Timestamp:
2012-04-18T20:55:21Z (14 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/fix-logger-deadlock, topic/msim-upgrade, topic/simplify-dev-export
Children:
7769ec9
Parents:
e895352 (diff), 63920b0 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

merge mainline changes

Location:
uspace/drv/nic
Files:
10 added
6 edited
2 moved

Legend:

Unmodified
Added
Removed

  • uspace/drv/nic/lo/Makefile

    re895352 r49ff5f3  
    2828
    2929USPACE_PREFIX = ../../..
    30 LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBNET_PREFIX)/libnet.a $(LIBNIC_PREFIX)/libnic.a
    31 EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBNET_PREFIX)/include -I$(LIBNIC_PREFIX)/include
     30LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBNIC_PREFIX)/libnic.a
     31EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBNIC_PREFIX)/include
    3232BINARY = lo
    3333

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

    re895352 r49ff5f3  
    4242#include <async.h>
    4343#include <nic.h>
    44 #include <packet_client.h>
    4544
    4645#define NAME  "lo"
    … …  
    5958};
    6059
    61 static void lo_write_packet(nic_t *nic_data, packet_t *packet)
     60static void lo_send_frame(nic_t *nic_data, void *data, size_t size)
    6261{
    63         nic_report_send_ok(nic_data, 1, packet_get_data_length(packet));
    64         nic_received_noneth_packet(nic_data, packet);
     62        nic_report_send_ok(nic_data, 1, size);
     63        nic_received_noneth_frame(nic_data, data, size);
    6564}
    6665
    … …  
    7978}
    8079
    81 static int lo_add_device(ddf_dev_t *dev)
     80static int lo_dev_add(ddf_dev_t *dev)
    8281{
    83         nic_t *nic_data = nic_create_and_bind(dev);
    84         if (nic_data == NULL) {
     82        ddf_fun_t *fun = NULL;
     83        bool bound = false;
     84       
     85        nic_t *nic = nic_create_and_bind(dev);
     86        if (nic == NULL) {
    8587                printf("%s: Failed to initialize\n", NAME);
    8688                return ENOMEM;
    8789        }
    8890       
    89         dev->driver_data = nic_data;
    90         nic_set_write_packet_handler(nic_data, lo_write_packet);
     91        dev->driver_data = nic;
     92        nic_set_send_frame_handler(nic, lo_send_frame);
    9193       
    92         int rc = nic_connect_to_services(nic_data);
     94        int rc = nic_connect_to_services(nic);
    9395        if (rc != EOK) {
    9496                printf("%s: Failed to connect to services\n", NAME);
    95                 nic_unbind_and_destroy(dev);
    96                 return rc;
     97                goto error;
    9798        }
    9899       
    99         rc = nic_register_as_ddf_fun(nic_data, &lo_dev_ops);
     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;
     105        }
     106        nic_set_ddf_fun(nic, fun);
     107        fun->ops = &lo_dev_ops;
     108        fun->driver_data = nic;
     109       
     110        rc = nic_report_address(nic, &lo_addr);
    100111        if (rc != EOK) {
    101                 printf("%s: Failed to register as DDF function\n", NAME);
    102                 nic_unbind_and_destroy(dev);
    103                 return rc;
     112                printf("%s: Failed to setup loopback address\n", NAME);
     113                goto error;
    104114        }
    105115       
    106         rc = nic_report_address(nic_data, &lo_addr);
     116        rc = ddf_fun_bind(fun);
    107117        if (rc != EOK) {
    108                 printf("%s: Failed to setup loopback address\n", NAME);
    109                 nic_unbind_and_destroy(dev);
    110                 return rc;
     118                printf("%s: Failed binding function\n", NAME);
     119                goto error;
    111120        }
     121        bound = true;
     122       
     123        rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
     124        if (rc != EOK)
     125                goto error;
    112126       
    113127        printf("%s: Adding loopback device '%s'\n", NAME, dev->name);
    114128        return EOK;
     129       
     130error:
     131        if (bound)
     132                ddf_fun_unbind(fun);
     133       
     134        if (fun != NULL)
     135                ddf_fun_destroy(fun);
     136       
     137        nic_unbind_and_destroy(dev);
     138        return rc;
    115139}
    116140
    … …  
    118142
    119143static driver_ops_t lo_driver_ops = {
    120         .add_device = lo_add_device,
     144        .dev_add = lo_dev_add,
    121145};
    122146

  • uspace/drv/nic/ne2k/Makefile

    re895352 r49ff5f3  
    2828
    2929USPACE_PREFIX = ../../..
    30 LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBNET_PREFIX)/libnet.a $(LIBNIC_PREFIX)/libnic.a
    31 EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBNET_PREFIX)/include -I$(LIBNIC_PREFIX)/include
     30LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBNIC_PREFIX)/libnic.a
     31EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBNIC_PREFIX)/include
    3232BINARY = ne2k
    3333

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

    re895352 r49ff5f3  
    5959#include <stdio.h>
    6060#include <libarch/ddi.h>
    61 #include <net/packet.h>
    62 #include <packet_client.h>
    6361#include "dp8390.h"
    6462
    … …  
    7674        uint8_t status;
    7775       
    78         /** Pointer to next packet */
     76        /** Pointer to next frame */
    7977        uint8_t next;
    8078       
    … …  
    142140static void ne2k_upload(ne2k_t *ne2k, void *buf, size_t addr, size_t size)
    143141{
     142        size_t esize_ru = (size + 1) & ~1;
    144143        size_t esize = size & ~1;
    145144       
    146         pio_write_8(ne2k->port + DP_RBCR0, esize & 0xff);
    147         pio_write_8(ne2k->port + DP_RBCR1, (esize >> 8) & 0xff);
     145        pio_write_8(ne2k->port + DP_RBCR0, esize_ru & 0xff);
     146        pio_write_8(ne2k->port + DP_RBCR1, (esize_ru >> 8) & 0xff);
    148147        pio_write_8(ne2k->port + DP_RSAR0, addr & 0xff);
    149148        pio_write_8(ne2k->port + DP_RSAR1, (addr >> 8) & 0xff);
    … …  
    392391        /*
    393392         * Reset the transmit ring. If we were transmitting a frame,
    394          * we pretend that the packet is processed. Higher layers will
    395          * retransmit if the packet wasn't actually sent.
     393         * we pretend that the frame is processed. Higher layers will
     394         * retransmit if the frame wasn't actually sent.
    396395         */
    397396        ne2k->sq.dirty = false;
    … …  
    403402 *
    404403 * @param[in,out] ne2k   Network interface structure.
    405  * @param[in]     packet Frame to be sent.
    406  *
    407  */
    408 void ne2k_send(nic_t *nic_data, packet_t *packet)
     404 * @param[in]     data   Pointer to frame data
     405 * @param[in]     size   Frame size in bytes
     406 *
     407 */
     408void ne2k_send(nic_t *nic_data, void *data, size_t size)
    409409{
    410410        ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
    … …  
    418418                fibril_condvar_wait(&ne2k->sq_cv, &ne2k->sq_mutex);
    419419        }
    420         void *buf = packet_get_data(packet);
    421         size_t size = packet_get_data_length(packet);
    422420       
    423421        if ((size < ETH_MIN_PACK_SIZE) || (size > ETH_MAX_PACK_SIZE_TAGGED)) {
    … …  
    427425
    428426        /* Upload the frame to the ethernet card */
    429         ne2k_upload(ne2k, buf, ne2k->sq.page * DP_PAGE, size);
     427        ne2k_upload(ne2k, data, ne2k->sq.page * DP_PAGE, size);
    430428        ne2k->sq.dirty = true;
    431429        ne2k->sq.size = size;
    … …  
    437435        pio_write_8(ne2k->port + DP_CR, CR_TXP | CR_STA);
    438436        fibril_mutex_unlock(&ne2k->sq_mutex);
    439 
    440         /* Relase packet */
    441         nic_release_packet(nic_data, packet);
    442437}
    443438
    … …  
    451446                return NULL;
    452447       
    453         void *buf = packet_suffix(frame->packet, length);
    454         bzero(buf, length);
     448        bzero(frame->data, length);
    455449        uint8_t last = page + length / DP_PAGE;
    456450       
    … …  
    458452                size_t left = (ne2k->stop_page - page) * DP_PAGE
    459453                    - sizeof(recv_header_t);
    460                 ne2k_download(ne2k, buf, page * DP_PAGE + sizeof(recv_header_t),
     454                ne2k_download(ne2k, frame->data, page * DP_PAGE + sizeof(recv_header_t),
    461455                    left);
    462                 ne2k_download(ne2k, buf + left, ne2k->start_page * DP_PAGE,
     456                ne2k_download(ne2k, frame->data + left, ne2k->start_page * DP_PAGE,
    463457                    length - left);
    464458        } else {
    465                 ne2k_download(ne2k, buf, page * DP_PAGE + sizeof(recv_header_t),
     459                ne2k_download(ne2k, frame->data, page * DP_PAGE + sizeof(recv_header_t),
    466460                    length);
    467461        }
    … …  
    544538                 * Update the boundary pointer
    545539                 * to the value of the page
    546                  * prior to the next packet to
     540                 * prior to the next frame to
    547541                 * be processed.
    548542                 */
    … …  
    587581                fibril_mutex_lock(&ne2k->sq_mutex);
    588582                if (ne2k->sq.dirty) {
    589                         /* Prepare the buffer for next packet */
     583                        /* Prepare the buffer for next frame */
    590584                        ne2k->sq.dirty = false;
    591585                        ne2k->sq.size = 0;

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

    re895352 r49ff5f3  
    262262extern int ne2k_up(ne2k_t *);
    263263extern void ne2k_down(ne2k_t *);
    264 extern void ne2k_send(nic_t *, packet_t *);
     264extern void ne2k_send(nic_t *, void *, size_t);
    265265extern void ne2k_interrupt(nic_t *, uint8_t, uint8_t);
    266 extern packet_t *ne2k_alloc_packet(nic_t *, size_t);
    267266
    268267extern void ne2k_set_accept_mcast(ne2k_t *, int);

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

    re895352 r49ff5f3  
    6464#define NE2K(device) ((ne2k_t *) nic_get_specific(DRIVER_DATA(device)))
    6565
     66static irq_pio_range_t ne2k_ranges_prototype[] = {
     67        {
     68                .base = 0,
     69                .size = NE2K_IO_SIZE,
     70        }
     71};
     72
    6673/** NE2000 kernel interrupt command sequence.
    6774 *
    … …  
    122129
    123130        if (ne2k->code.cmdcount == 0) {
    124                 irq_cmd_t *ne2k_cmds = malloc(sizeof(ne2k_cmds_prototype));
    125                 if (ne2k_cmds == NULL) {
     131                irq_pio_range_t *ne2k_ranges;
     132                irq_cmd_t *ne2k_cmds;
     133
     134                ne2k_ranges = malloc(sizeof(ne2k_ranges_prototype));
     135                if (!ne2k_ranges)
     136                        return ENOMEM;
     137                memcpy(ne2k_ranges, ne2k_ranges_prototype,
     138                    sizeof(ne2k_ranges_prototype));
     139                ne2k_ranges[0].base = (uintptr_t) ne2k->base_port;
     140
     141                ne2k_cmds = malloc(sizeof(ne2k_cmds_prototype));
     142                if (!ne2k_cmds) {
     143                        free(ne2k_ranges);
    126144                        return ENOMEM;
    127145                }
    128                 memcpy(ne2k_cmds, ne2k_cmds_prototype, sizeof (ne2k_cmds_prototype));
    129                 ne2k_cmds[0].addr = ne2k->port + DP_ISR;
    130                 ne2k_cmds[3].addr = ne2k->port + DP_IMR;
     146                memcpy(ne2k_cmds, ne2k_cmds_prototype,
     147                    sizeof(ne2k_cmds_prototype));
     148                ne2k_cmds[0].addr = ne2k->base_port + DP_ISR;
     149                ne2k_cmds[3].addr = ne2k->base_port + DP_IMR;
    131150                ne2k_cmds[4].addr = ne2k_cmds[0].addr;
    132                 ne2k_cmds[5].addr = ne2k->port + DP_TSR;
    133 
    134                 ne2k->code.cmdcount = sizeof(ne2k_cmds_prototype) / sizeof(irq_cmd_t);
     151                ne2k_cmds[5].addr = ne2k->base_port + DP_TSR;
     152
     153                ne2k->code.rangecount = sizeof(ne2k_ranges_prototype) /
     154                    sizeof(irq_pio_range_t);
     155                ne2k->code.ranges = ne2k_ranges;
     156
     157                ne2k->code.cmdcount = sizeof(ne2k_cmds_prototype) /
     158                    sizeof(irq_cmd_t);
    135159                ne2k->code.cmds = ne2k_cmds;
    136160        }
    … …  
    148172                ne2k_t *ne2k = NE2K(dev);
    149173                if (ne2k) {
     174                        free(ne2k->code.ranges);
    150175                        free(ne2k->code.cmds);
    151176                }
    … …  
    261286        /* Note: some frame with previous physical address may slip to NIL here
    262287         * (for a moment the filtering is not exact), but ethernet should be OK with
    263          * that. Some packet may also be lost, but this is not a problem.
     288         * that. Some frames may also be lost, but this is not a problem.
    264289         */
    265290        ne2k_set_physical_address((ne2k_t *) nic_get_specific(nic_data), address);
    … …  
    336361}
    337362
    338 static int ne2k_add_device(ddf_dev_t *dev)
    339 {
     363static int ne2k_dev_add(ddf_dev_t *dev)
     364{
     365        ddf_fun_t *fun;
     366       
    340367        /* Allocate driver data for the device. */
    341368        nic_t *nic_data = nic_create_and_bind(dev);
    … …  
    343370                return ENOMEM;
    344371       
    345         nic_set_write_packet_handler(nic_data, ne2k_send);
     372        nic_set_send_frame_handler(nic_data, ne2k_send);
    346373        nic_set_state_change_handlers(nic_data,
    347374                ne2k_on_activating, NULL, ne2k_on_stopping);
    … …  
    371398        }
    372399       
    373         rc = nic_register_as_ddf_fun(nic_data, &ne2k_dev_ops);
     400        rc = nic_connect_to_services(nic_data);
    374401        if (rc != EOK) {
    375402                ne2k_dev_cleanup(dev);
    … …  
    377404        }
    378405       
    379         rc = nic_connect_to_services(nic_data);
    380         if (rc != EOK) {
     406        fun = ddf_fun_create(nic_get_ddf_dev(nic_data), fun_exposed, "port0");
     407        if (fun == NULL) {
    381408                ne2k_dev_cleanup(dev);
     409                return ENOMEM;
     410        }
     411        nic_set_ddf_fun(nic_data, fun);
     412        fun->ops = &ne2k_dev_ops;
     413        fun->driver_data = nic_data;
     414       
     415        rc = ddf_fun_bind(fun);
     416        if (rc != EOK) {
     417                ddf_fun_destroy(fun);
     418                ne2k_dev_cleanup(dev);
     419                return rc;
     420        }
     421       
     422        rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
     423        if (rc != EOK) {
     424                ddf_fun_unbind(fun);
     425                ddf_fun_destroy(fun);
    382426                return rc;
    383427        }
    … …  
    391435
    392436static driver_ops_t ne2k_driver_ops = {
    393         .add_device = ne2k_add_device
     437        .dev_add = ne2k_dev_add
    394438};
    395439

  • uspace/drv/nic/rtl8139/Makefile

    re895352 r49ff5f3  
    11#
    2 # Copyright (c) 2005 Martin Decky
    3 # Copyright (c) 2007 Jakub Jermar
     2# Copyright (c) 2011 Radim Vansa
    43# All rights reserved.
    54#
    … …  
    2827#
    2928
    30 USPACE_PREFIX = ../../../..
    31 LIBS = $(LIBNET_PREFIX)/libnet.a
    32 EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
    33 BINARY = icmp
    34 STATIC_ONLY = y
     29USPACE_PREFIX = ../../..
     30LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBNIC_PREFIX)/libnic.a
     31EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBNIC_PREFIX)/include
     32BINARY = rtl8139
    3533
    3634SOURCES = \
    37         icmp.c
     35        driver.c \
     36        general.c \
     37        defs.c
    3838
    3939include $(USPACE_PREFIX)/Makefile.common

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

    re895352 r49ff5f3  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2011 Jiri Michalec
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libc
    30  * @{
     29/** @file
     30 *
     31 * General functions and structures used in rtl8139 driver
    3132 */
    3233
    33 /** @file
    34  * ARP module messages.
    35  * @see arp_interface.h
    36  */
     34#ifndef RTL8139_GENERAL_H_
     35#define RTL8139_GENERAL_H_
    3736
    38 #ifndef LIBC_ARP_MESSAGES_
    39 #define LIBC_ARP_MESSAGES_
     37#include <unistd.h>
    4038
    41 #include <ipc/net.h>
     39/** Number of microseconds in second */
     40#define RTL8139_USEC_IN_SEC  1000000
    4241
    43 /** ARP module messages. */
    44 typedef enum {
    45         /** Clean cache message.
    46          * @see arp_clean_cache()
    47          */
    48         NET_ARP_CLEAN_CACHE = NET_ARP_FIRST,
    49         /** Clear address cache message.
    50          * @see arp_clear_address_msg()
    51          */
    52         NET_ARP_CLEAR_ADDRESS,
    53         /** Clear device cache message.
    54          * @see arp_clear_device_req()
    55          */
    56         NET_ARP_CLEAR_DEVICE,
    57         /** New device message.
    58          * @see arp_device_req()
    59          */
    60         NET_ARP_DEVICE,
    61         /** Address translation message.
    62          * @see arp_translate_req()
    63          */
    64         NET_ARP_TRANSLATE
    65 } arp_messages;
     42/** Structure for HW timer control */
     43typedef struct {
     44        /** Register value set in the last timer period */
     45        uint32_t last_val;
     46       
     47        /** Register value set in the common timer period */
     48        uint32_t full_val;
     49       
     50        /** Amount of full register periods in timer period */
     51        size_t full_skips;
     52       
     53        /** Remaining full register periods to the next period end */
     54        size_t full_skips_remains;
     55       
     56        /** Mark if there is a last run */
     57        int last_run;
     58} rtl8139_timer_act_t;
    6659
    67 /** @name ARP specific message parameters definitions */
    68 /*@{*/
    69 
    70 /** Return the protocol service message parameter.
    71  *
    72  * @param[in] call Message call structure.
    73  *
    74  */
    75 #define ARP_GET_NETIF(call) ((services_t) IPC_GET_ARG2(call))
    76 
    77 /*@}*/
     60extern void *rtl8139_memcpy_wrapped(void *, const void *, size_t, size_t,
     61    size_t);
     62extern int rtl8139_timer_act_init(rtl8139_timer_act_t *, uint32_t,
     63    const struct timeval *);
     64extern int rtl8139_timer_act_step(rtl8139_timer_act_t *, uint32_t *);
    7865
    7966#endif
    80 
    81 /** @}
    82  */
Note: See TracChangeset for help on using the changeset viewer.