Changeset ecf823a in mainline


Ignore:
Timestamp:
2011-12-31T10:01:19Z (13 years ago)
Author:
Frantisek Princ <frantisek.princ@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
96cd5b4
Parents:
3819ce5 (diff), 852052d (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 with mainline

Files:
1 added
17 edited

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    r3819ce5 recf823a  
    128128        nic/lo \
    129129        nic/ne2k \
    130         nic/e1k
     130        nic/e1k \
     131        nic/rtl8139
    131132
    132133RD_DRV_CFG =

  • contrib/conf/net-qe.sh

    r3819ce5 recf823a  
    1010                qemu $@ -device e1000,vlan=0 -net user -boot d -redir udp:8080::8080 -redir udp:8081::8081 -redir tcp:8080::8080 -redir tcp:8081::8081 -cdrom image.iso
    1111                ;;
     12        rtl8139)
     13                shift
     14                qemu $@ -device rtl8139,vlan=0 -net user -boot d -redir udp:8080::8080 -redir udp:8081::8081 -redir tcp:8080::8080 -redir tcp:8081::8081 -cdrom image.iso
     15                ;;
    1216        *)
    13                 echo "Usage: $0 {ne2k|e1k}"
     17                echo "Usage: $0 {ne2k|e1k|rtl8139}"
    1418esac

  • uspace/Makefile

    r3819ce5 recf823a  
    122122        drv/nic/lo \
    123123        drv/nic/ne2k \
    124         drv/nic/e1k
     124        drv/nic/e1k \
     125        drv/nic/rtl8139
    125126
    126127ifeq ($(CONFIG_PCC),y)

  • uspace/app/websrv/websrv.c

    r3819ce5 recf823a  
    4949
    5050#define PORT_NUMBER 8080
     51#define BACKLOG_SIZE 3
    5152
    5253#define WEB_ROOT "/data/web"
    … …  
    275276        }
    276277
    277         rc = listen(listen_sd, 1);
     278        rc = listen(listen_sd, BACKLOG_SIZE);
    278279        if (rc != EOK) {
    279280                printf("Error calling listen() (%d).\n", rc);

  • uspace/dist/data/web/index.htm

    r3819ce5 recf823a  
    77    <body>
    88        <h1>Hello from HelenOS!</h1>
     9        <img src="helenos.png" alt="" style="float: left; margin: 6px;">
    910        <p>
    1011            This web page is brought to you by courtesy of HelenOS web server

  • uspace/drv/bus/usb/ohci/root_hub.c

    r3819ce5 recf823a  
    226226                fibril_mutex_lock(&instance->guard);
    227227                assert(instance->unfinished_interrupt_transfer == NULL);
    228                 const uint16_t mask = create_interrupt_mask(instance);
     228                uint16_t mask = create_interrupt_mask(instance);
    229229                if (mask == 0) {
    230230                        usb_log_debug("No changes...\n");
    … …  
    257257        if (instance->unfinished_interrupt_transfer) {
    258258                usb_log_debug("Finalizing interrupt transfer\n");
    259                 const uint16_t mask = create_interrupt_mask(instance);
     259                uint16_t mask = create_interrupt_mask(instance);
    260260                interrupt_request(instance->unfinished_interrupt_transfer,
    261261                    mask, instance->interrupt_mask_size);
    … …  
    278278
    279279        /* 7 bytes + 2 port bit fields (port count + global bit) */
    280         const size_t size = 7 + (instance->interrupt_mask_size * 2);
     280        size_t size = 7 + (instance->interrupt_mask_size * 2);
    281281        assert(size <= HUB_DESCRIPTOR_MAX_SIZE);
    282282        instance->hub_descriptor_size = size;
    283283
    284         const uint32_t hub_desc = instance->registers->rh_desc_a;
    285         const uint32_t port_desc = instance->registers->rh_desc_b;
     284        uint32_t hub_desc = instance->registers->rh_desc_a;
     285        uint32_t port_desc = instance->registers->rh_desc_b;
    286286
    287287        /* bDescLength */
    … …  
    394394
    395395
    396         const usb_device_request_setup_packet_t *request_packet =
     396        usb_device_request_setup_packet_t *request_packet =
    397397            (usb_device_request_setup_packet_t*)request->setup_buffer;
    398398
    … …  
    406406                        TRANSFER_END(request, EOVERFLOW);
    407407                } else {
    408                         const uint32_t data = instance->registers->rh_status &
     408                        uint32_t data = instance->registers->rh_status &
    409409                            (RHS_LPS_FLAG | RHS_LPSC_FLAG
    410410                                | RHS_OCI_FLAG | RHS_OCIC_FLAG);
    … …  
    420420                        TRANSFER_END(request, EOVERFLOW);
    421421                } else {
    422                         const unsigned port = request_packet->index;
     422                        unsigned port = request_packet->index;
    423423                        if (port < 1 || port > instance->port_count)
    424424                                TRANSFER_END(request, EINVAL);
    425425
    426                         const uint32_t data =
     426                        uint32_t data =
    427427                            instance->registers->rh_port_status[port - 1];
    428428                        TRANSFER_END_DATA(request, &data, sizeof(data));
    … …  
    434434                        TRANSFER_END(request, EOVERFLOW);
    435435                } else {
    436                         static const uint16_t data =
     436                        uint16_t data =
    437437                            uint16_host2usb(USB_DEVICE_STATUS_SELF_POWERED);
    438438                        TRANSFER_END_DATA(request, &data, sizeof(data));
    … …  
    455455                } else {
    456456                        /* Endpoints are OK. (We don't halt) */
    457                         static const uint16_t data = 0;
     457                        uint16_t data = 0;
    458458                        TRANSFER_END_DATA(request, &data, sizeof(data));
    459459                }
    … …  
    480480        assert(request);
    481481
    482         const usb_device_request_setup_packet_t *setup_request =
     482        usb_device_request_setup_packet_t *setup_request =
    483483            (usb_device_request_setup_packet_t *) request->setup_buffer;
    484         const uint16_t setup_request_value = setup_request->value_high;
     484        uint16_t setup_request_value = setup_request->value_high;
    485485        switch (setup_request_value)
    486486        {
    … …  
    648648        assert(request);
    649649
    650         const usb_device_request_setup_packet_t *setup_request =
     650        usb_device_request_setup_packet_t *setup_request =
    651651            (usb_device_request_setup_packet_t *) request->setup_buffer;
    652652        switch (setup_request->request_type)
    … …  
    654654        case USB_HUB_REQ_TYPE_SET_PORT_FEATURE:
    655655                usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
    656                 const int ret = set_feature_port(instance,
     656                int ret = set_feature_port(instance,
    657657                    setup_request->value, setup_request->index);
    658658                TRANSFER_END(request, ret);
    … …  
    686686        assert(request);
    687687
    688         const usb_device_request_setup_packet_t *setup_request =
     688        usb_device_request_setup_packet_t *setup_request =
    689689            (usb_device_request_setup_packet_t *) request->setup_buffer;
    690690
    … …  
    693693        case USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE:
    694694                usb_log_debug("USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE\n");
    695                 const int ret = clear_feature_port(instance,
     695                int ret = clear_feature_port(instance,
    696696                    setup_request->value, setup_request->index);
    697697                TRANSFER_END(request, ret);
    … …  
    753753        usb_log_debug2("CTRL packet: %s.\n",
    754754            usb_debug_str_buffer((uint8_t *) request->setup_buffer, 8, 8));
    755         const usb_device_request_setup_packet_t *setup_request =
     755        usb_device_request_setup_packet_t *setup_request =
    756756            (usb_device_request_setup_packet_t *) request->setup_buffer;
    757757        switch (setup_request->request)
    … …  
    771771                if (request->buffer_size == 0)
    772772                        TRANSFER_END(request, EOVERFLOW);
    773                 static const uint8_t config = 1;
     773                uint8_t config = 1;
    774774                TRANSFER_END_DATA(request, &config, sizeof(config));
    775775

  • uspace/drv/infrastructure/rootmac/rootmac.c

    r3819ce5 recf823a  
    161161
    162162static hw_res_ops_t fun_hw_res_ops = {
    163         &rootmac_get_resources,
    164         &rootmac_enable_interrupt
     163        .get_resource_list = &rootmac_get_resources,
     164        .enable_interrupt = &rootmac_enable_interrupt
    165165};
    166166

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

    r3819ce5 recf823a  
    2727 */
    2828
    29 #include "rtl8139_defs.h"
     29#include "defs.h"
    3030
    3131const char* model_names[RTL8139_VER_COUNT] = {

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

    r3819ce5 recf823a  
    3333#include <libarch/ddi.h>
    3434#include <libarch/barrier.h>
    35 #include <nlog.h>
    36 
    37 #include <dma.h>
     35
     36#include <as.h>
     37#include <ddf/log.h>
    3838#include <ddf/interrupt.h>
    39 #include <devman.h>
     39#include <io/log.h>
    4040#include <nic.h>
    4141#include <packet_client.h>
    … …  
    5050#include <str.h>
    5151
    52 #include "rtl8139_defs.h"
    53 #include "rtl8139_driver.h"
    54 #include "rtl8139_general.h"
     52#include "defs.h"
     53#include "driver.h"
     54#include "general.h"
    5555
    5656/** Global mutex for work with shared irq structure */
    … …  
    164164            (RXBUF_SIZE_FLAGS << RCR_RBLEN_SHIFT);
    165165       
    166         nlog_debug("Rewriting rcr: %x -> %x", pio_read_32(rtl8139->io_port + RCR),
     166        ddf_msg(LVL_DEBUG, "Rewriting rcr: %x -> %x", pio_read_32(rtl8139->io_port + RCR),
    167167            rcr);
    168168
    … …  
    373373static ddf_dev_ops_t rtl8139_dev_ops;
    374374
    375 static int rtl8139_add_device(ddf_dev_t *dev);
     375static int rtl8139_dev_add(ddf_dev_t *dev);
    376376
    377377/** Basic driver operations for RTL8139 driver */
    378378static driver_ops_t rtl8139_driver_ops = {
    379         .add_device = &rtl8139_add_device,
     379        .dev_add = &rtl8139_dev_add,
    380380};
    381381
    … …  
    409409        rtl8139_t *rtl8139 = nic_get_specific(nic_data);
    410410        assert(rtl8139);
    411         nlog_debug("Sending packet");
     411        ddf_msg(LVL_DEBUG, "Sending packet");
    412412
    413413        /* Get the packet data and check if it can be send */
    … …  
    418418
    419419        if ((packet_length > RTL8139_PACKET_MAX_LENGTH) || !packet_data) {
    420                 nlog_error("Write packet length error: data %p, length %z",
     420                ddf_msg(LVL_ERROR, "Write packet length error: data %p, length %z",
    421421                    packet_data, packet_length);
    422422                nic_report_send_error(rtl8139->nic_data, NIC_SEC_OTHER, 1);
    … …  
    527527        nic_frame_t *frame = nic_alloc_frame(nic_data, packet_size);
    528528        if (! frame) {
    529                 nlog_error("Can not allocate frame for received packet.");
     529                ddf_msg(LVL_ERROR, "Can not allocate frame for received packet.");
    530530                return NULL;
    531531        }
    … …  
    533533        void *packet_data = packet_suffix(frame->packet, packet_size);
    534534        if (!packet_data) {
    535                 nlog_error("Can not get the packet suffix.");
     535                ddf_msg(LVL_ERROR, "Can not get the packet suffix.");
    536536                nic_release_frame(nic_data, frame);
    537537                return NULL;
    … …  
    564564        pio_write_32(rtl8139->io_port + CAPR, 0);
    565565        pio_write_32(rtl8139->io_port + RBSTART,
    566             PTR2U32(rtl8139->rx_buff.physical));
     566            PTR2U32(rtl8139->rx_buff_phys));
    567567
    568568        write_barrier();
    … …  
    588588        nic_frame_list_t *frames = nic_alloc_frame_list();
    589589        if (!frames)
    590                 nlog_error("Can not allocate frame list for received packets.");
    591 
    592         void *rx_buffer = rtl8139->rx_buff.virtual;
     590                ddf_msg(LVL_ERROR, "Can not allocate frame list for received packets.");
     591
     592        void *rx_buffer = rtl8139->rx_buff_virt;
    593593
    594594        /* where to start reading */
    … …  
    620620                if (size == RTL8139_EARLY_SIZE) {
    621621                        /* The packet copying is still in progress, break receiving */
    622                         nlog_debug("Early threshold reached, not completely coppied");
     622                        ddf_msg(LVL_DEBUG, "Early threshold reached, not completely coppied");
    623623                        break;
    624624                }
    … …  
    626626                /* Check if the header is valid, otherwise we are lost in the buffer */
    627627                if (size == 0 || size > RTL8139_PACKET_MAX_LENGTH) {
    628                         nlog_error("Receiver error -> receiver reset (size: %4"PRIu16", "
     628                        ddf_msg(LVL_ERROR, "Receiver error -> receiver reset (size: %4"PRIu16", "
    629629                            "header 0x%4"PRIx16". Offset: %zu)", size, packet_header,
    630630                            rx_offset);
    … …  
    632632                }
    633633                if (size < RTL8139_RUNT_MAX_SIZE && !(rcs & RSR_RUNT)) {
    634                         nlog_error("Receiver error -> receiver reset (%"PRIx16")", size);
     634                        ddf_msg(LVL_ERROR, "Receiver error -> receiver reset (%"PRIx16")", size);
    635635                        goto rx_err;
    636636                }
    … …  
    801801        pio_write_32(rtl8139->io_port + TIMERINT, timer_val);
    802802        pio_write_32(rtl8139->io_port + TCTR, 0x0);
    803         nlog_debug("rtl8139 timer: %"PRIu32"\treceive: %d", timer_val, receive);
     803        ddf_msg(LVL_DEBUG, "rtl8139 timer: %"PRIu32"\treceive: %d", timer_val, receive);
    804804        return receive;
    805805}
    … …  
    925925        /* Write transmittion buffer addresses */
    926926        for(i = 0; i < TX_BUFF_COUNT; ++i) {
    927                 uint32_t addr = PTR2U32(rtl8139->tx_buff_mem.physical + i*TX_BUFF_SIZE);
     927                uint32_t addr = PTR2U32(rtl8139->tx_buff_phys + i*TX_BUFF_SIZE);
    928928                pio_write_32(io_base + TSAD0 + 4*i, addr);
    929929        }
    … …  
    932932        nic_set_tx_busy(rtl8139->nic_data, 0);
    933933
    934         pio_write_32(io_base + RBSTART, PTR2U32(rtl8139->rx_buff.physical));
     934        pio_write_32(io_base + RBSTART, PTR2U32(rtl8139->rx_buff_phys));
    935935
    936936        /* Enable transmitter and receiver */
    … …  
    949949{
    950950        assert(nic_data);
    951         nlog_info("Activating device");
     951        ddf_msg(LVL_NOTE, "Activating device");
    952952
    953953        rtl8139_t *rtl8139 = nic_get_specific(nic_data);
    … …  
    962962        nic_enable_interrupt(nic_data, rtl8139->irq);
    963963
    964         nlog_debug("Device activated, interrupt %d registered", rtl8139->irq);
     964        ddf_msg(LVL_DEBUG, "Device activated, interrupt %d registered", rtl8139->irq);
    965965        return EOK;
    966966}
    … …  
    10791079
    10801080        if (hw_resources->irqs.count != 1) {
    1081                 nlog_error("%s device: unexpected irq count", dev->name);
     1081                ddf_msg(LVL_ERROR, "%s device: unexpected irq count", dev->name);
    10821082                return EINVAL;
    10831083        };
    10841084        if (hw_resources->io_ranges.count != 1) {
    1085                 nlog_error("%s device: unexpected io ranges count", dev->name);
     1085                ddf_msg(LVL_ERROR, "%s device: unexpected io ranges count", dev->name);
    10861086                return EINVAL;
    10871087        }
    10881088
    10891089        rtl8139->irq = hw_resources->irqs.irqs[0];
    1090         nlog_debug("%s device: irq 0x%x assigned", dev->name, rtl8139->irq);
     1090        ddf_msg(LVL_DEBUG, "%s device: irq 0x%x assigned", dev->name, rtl8139->irq);
    10911091
    10921092        rtl8139->io_addr = IOADDR_TO_PTR(hw_resources->io_ranges.ranges[0].address);
    10931093        if (hw_resources->io_ranges.ranges[0].size < RTL8139_IO_SIZE) {
    1094                 nlog_error("i/o range assigned to the device "
     1094                ddf_msg(LVL_ERROR, "i/o range assigned to the device "
    10951095                    "%s is too small.", dev->name);
    10961096                return EINVAL;
    10971097        }
    1098         nlog_debug("%s device: i/o addr %p assigned.", dev->name, rtl8139->io_addr);
     1098        ddf_msg(LVL_DEBUG, "%s device: i/o addr %p assigned.", dev->name, rtl8139->io_addr);
    10991099
    11001100        return EOK;
    … …  
    11421142static int rtl8139_buffers_create(rtl8139_t *rtl8139)
    11431143{
    1144         assert(rtl8139);
    11451144        size_t i = 0;
    11461145        int rc;
    11471146
    1148         nlog_debug("Creating buffers");
    1149 
    1150         rtl8139->tx_buff_mem.size = TX_PAGES;
    1151         rtl8139->tx_buff_mem.mapping_flags = AS_AREA_WRITE;
    1152         rc = dma_allocate_anonymous(&rtl8139->tx_buff_mem, DMA_32_BITS);
     1147        ddf_msg(LVL_DEBUG, "Creating buffers");
     1148
     1149        rc = dmamem_map_anonymous(TX_PAGES * PAGE_SIZE, AS_AREA_WRITE, 0,
     1150            &rtl8139->tx_buff_phys, &rtl8139->tx_buff_virt);
    11531151        if (rc != EOK) {
    1154                 nlog_error("Can not allocate transmitter buffers.");
     1152                ddf_msg(LVL_ERROR, "Can not allocate transmitter buffers.");
    11551153                goto err_tx_alloc;
    11561154        }
    11571155
    1158         for(i = 0; i < TX_BUFF_COUNT; ++i)
    1159                 rtl8139->tx_buff[i] = rtl8139->tx_buff_mem.virtual + i * TX_BUFF_SIZE;
    1160 
    1161         nlog_debug("The transmittion buffers allocated");
     1156        for (i = 0; i < TX_BUFF_COUNT; ++i)
     1157                rtl8139->tx_buff[i] = rtl8139->tx_buff_virt + i * TX_BUFF_SIZE;
     1158
     1159        ddf_msg(LVL_DEBUG, "The transmittion buffers allocated");
    11621160
    11631161        /* Use the first buffer for next transmittion */
    … …  
    11661164
    11671165        /* Allocate buffer for receiver */
    1168         size_t rx_pages = ALIGN_UP(RxBUF_TOT_LENGTH, PAGE_SIZE) / PAGE_SIZE;
    1169         nlog_debug("Allocating receiver buffer of the size %zd pages", rx_pages);
    1170 
    1171         rtl8139->rx_buff.size = rx_pages;
    1172         rtl8139->rx_buff.mapping_flags = AS_AREA_READ;
    1173         rc = dma_allocate_anonymous(&rtl8139->rx_buff, DMA_32_BITS);
    1174         if( rc != EOK ) {
    1175                 nlog_error("Can not allocate receiver buffer.");
     1166        ddf_msg(LVL_DEBUG, "Allocating receiver buffer of the size %zu bytes",
     1167            RxBUF_TOT_LENGTH);
     1168
     1169        rc = dmamem_map_anonymous(RxBUF_TOT_LENGTH, AS_AREA_READ, 0,
     1170            &rtl8139->rx_buff_phys, &rtl8139->rx_buff_virt);
     1171        if (rc != EOK) {
     1172                ddf_msg(LVL_ERROR, "Can not allocate receive buffer.");
    11761173                goto err_rx_alloc;
    11771174        }
    1178         nlog_debug("The buffers created");
     1175        ddf_msg(LVL_DEBUG, "The buffers created");
    11791176
    11801177        return EOK;
    11811178
    11821179err_rx_alloc:
    1183         dma_free(&rtl8139->tx_buff_mem);
     1180        dmamem_unmap_anonymous(&rtl8139->tx_buff_virt);
    11841181err_tx_alloc:
    11851182        return rc;
    … …  
    11941191static int rtl8139_device_initialize(ddf_dev_t *dev)
    11951192{
    1196         nlog_debug("rtl8139_dev_initialize %s", dev->name);
     1193        ddf_msg(LVL_DEBUG, "rtl8139_dev_initialize %s", dev->name);
    11971194
    11981195        int ret = EOK;
    11991196
    1200         nlog_debug("rtl8139: creating device data");
     1197        ddf_msg(LVL_DEBUG, "rtl8139: creating device data");
    12011198
    12021199        /* Allocate driver data for the device. */
    12031200        rtl8139_t *rtl8139 = rtl8139_create_dev_data(dev);
    12041201        if (rtl8139 == NULL) {
    1205                 nlog_error("Not enough memory for initializing %s.", dev->name);
     1202                ddf_msg(LVL_ERROR, "Not enough memory for initializing %s.", dev->name);
    12061203                return ENOMEM;
    12071204        }
    12081205
    1209         nlog_debug("rtl8139: dev_data created");
     1206        ddf_msg(LVL_DEBUG, "rtl8139: dev_data created");
    12101207
    12111208        /* Obtain and fill hardware resources info and connect to parent */
    12121209        ret = rtl8139_get_resource_info(dev);
    12131210        if (ret != EOK) {
    1214                 nlog_error("Can not obatin hw resources information");
     1211                ddf_msg(LVL_ERROR, "Can not obatin hw resources information");
    12151212                goto failed;
    12161213        }
    12171214
    1218         nlog_debug("rtl8139: resource_info obtained");
     1215        ddf_msg(LVL_DEBUG, "rtl8139: resource_info obtained");
    12191216
    12201217        /* Allocate DMA buffers */
    … …  
    12311228        rtl8139->rcr_data.rcr_base = (0x8 << RCR_ERTH_SHIFT);
    12321229
    1233         nlog_debug("The device is initialized");
     1230        ddf_msg(LVL_DEBUG, "The device is initialized");
    12341231        return ret;
    12351232
    12361233failed:
    1237         nlog_error("The device initialization failed");
     1234        ddf_msg(LVL_ERROR, "The device initialization failed");
    12381235        rtl8139_dev_cleanup(dev);
    12391236        return ret;
    … …  
    12481245static int rtl8139_pio_enable(ddf_dev_t *dev)
    12491246{
    1250         nlog_debug(NAME ": rtl8139_pio_enable %s", dev->name);
     1247        ddf_msg(LVL_DEBUG, NAME ": rtl8139_pio_enable %s", dev->name);
    12511248
    12521249        rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_dev(dev));
    … …  
    12541251        /* Gain control over port's registers. */
    12551252        if (pio_enable(rtl8139->io_addr, RTL8139_IO_SIZE, &rtl8139->io_port)) {
    1256                 nlog_error("Cannot gain the port %lx for device %s.", rtl8139->io_addr,
     1253                ddf_msg(LVL_ERROR, "Cannot gain the port %lx for device %s.", rtl8139->io_addr,
    12571254                    dev->name);
    12581255                return EADDRNOTAVAIL;
    … …  
    12821279                if (rtl8139_versions[i].hwverid == hwverid) {
    12831280                        rtl8139->hw_version = rtl8139_versions[i].ver_id;
    1284                         nlog_info("HW version found: index %zu, ver_id %d (%s)", i,
     1281                        ddf_msg(LVL_NOTE, "HW version found: index %zu, ver_id %d (%s)", i,
    12851282                            rtl8139_versions[i].ver_id, model_names[rtl8139->hw_version]);
    12861283                }
    … …  
    12961293 * @return EOK if added successfully, negative error code otherwise
    12971294 */
    1298 int rtl8139_add_device(ddf_dev_t *dev)
     1295int rtl8139_dev_add(ddf_dev_t *dev)
    12991296{
    13001297        assert(dev);
    1301         nlog_info("RTL8139_add_device %s (handle = %d)", dev->name, dev->handle);
     1298        ddf_msg(LVL_NOTE, "RTL8139_dev_add %s (handle = %d)", dev->name, dev->handle);
    13021299
    13031300        /* Init device structure for rtl8139 */
    … …  
    13301327        rc = nic_connect_to_services(nic_data);
    13311328        if (rc != EOK) {
    1332                 nlog_error("Failed to connect to services", rc);
     1329                ddf_msg(LVL_ERROR, "Failed to connect to services", rc);
    13331330                goto err_irq;
    13341331        }
    … …  
    13361333        rc = nic_register_as_ddf_fun(nic_data, &rtl8139_dev_ops);
    13371334        if (rc != EOK) {
    1338                 nlog_error("Failed to register as DDF function - error %d", rc);
     1335                ddf_msg(LVL_ERROR, "Failed to register as DDF function - error %d", rc);
    13391336                goto err_irq;
    13401337        }
    13411338
    1342         nlog_info("The %s device has been successfully initialized.",
     1339        ddf_msg(LVL_NOTE, "The %s device has been successfully initialized.",
    13431340            dev->name);
    13441341
    … …  
    15811578
    15821579        if (allow_send && time > 0) {
    1583                 nlog_warning("Time setting is not supported in set_pause method.");
     1580                ddf_msg(LVL_WARN, "Time setting is not supported in set_pause method.");
    15841581        }
    15851582        return EOK;
    … …  
    21212118                pio_write_32(rtl8139->io_port + TCTR, 0);
    21222119
    2123                 nlog_debug("Periodic mode. Interrupt mask %"PRIx16", poll.full_skips %"
     2120                ddf_msg(LVL_DEBUG, "Periodic mode. Interrupt mask %"PRIx16", poll.full_skips %"
    21242121                    PRIu32", last timer %"PRIu32".", rtl8139->int_mask,
    21252122                    rtl8139->poll_timer.full_skips, rtl8139->poll_timer.last_val);
    … …  
    21682165                &rtl8139_driver_ops, &rtl8139_dev_ops, &rtl8139_nic_iface);
    21692166
    2170         nlog_set_min_severity(DEBUG);
    2171         nlog_info("HelenOS RTL8139 driver started");
     2167        ddf_log_init(NAME, LVL_ERROR);
     2168        ddf_msg(LVL_NOTE, "HelenOS RTL8139 driver started");
    21722169        return ddf_driver_main(&rtl8139_driver);
    21732170}

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

    r3819ce5 recf823a  
    3030#define RTL8139_DRIVER_H_
    3131
    32 #include "rtl8139_defs.h"
    33 #include "rtl8139_general.h"
     32#include "defs.h"
     33#include "general.h"
    3434#include <sys/types.h>
    3535#include <stdint.h>
    36 #include <dma.h>
    3736
    3837/** The driver name */
    … …  
    9796         *  Each buffer takes 2kB
    9897         */
    99         dma_mem_t tx_buff_mem;
     98        void *tx_buff_phys;
     99        void *tx_buff_virt;
     100
    100101        /** Virtual adresses of the Tx buffers */
    101102        void *tx_buff[TX_BUFF_COUNT];
    … …  
    112113
    113114        /** Buffer for receiving packets */
    114         dma_mem_t rx_buff;
     115        void *rx_buff_phys;
     116        void *rx_buff_virt;
    115117
    116118        /** Receiver control register data */

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

    r3819ce5 recf823a  
    3232 */
    3333
    34 #include "rtl8139_general.h"
     34#include "general.h"
    3535
    3636#include <mem.h>

  • uspace/srv/net/tl/tcp/conn.c

    r3819ce5 recf823a  
    121121        fibril_condvar_initialize(&conn->cstate_cv);
    122122
     123        conn->cstate_cb = NULL;
     124
    123125        conn->cstate = st_listen;
    124126        conn->reset = false;
    … …  
    243245        tcp_cstate_t old_state;
    244246
     247        log_msg(LVL_DEBUG, "tcp_conn_state_set(%p)", conn);
     248
    245249        old_state = conn->cstate;
    246250        conn->cstate = nstate;
    247251        fibril_condvar_broadcast(&conn->cstate_cv);
     252
     253        /* Run user callback function */
     254        if (conn->cstate_cb != NULL) {
     255                log_msg(LVL_DEBUG, "tcp_conn_state_set() - run user CB");
     256                conn->cstate_cb(conn, conn->cstate_cb_arg);
     257        } else {
     258                log_msg(LVL_DEBUG, "tcp_conn_state_set() - no user CB");
     259        }
    248260
    249261        assert(old_state != st_closed);

  • uspace/srv/net/tl/tcp/sock.c

    r3819ce5 recf823a  
    5252#define FRAGMENT_SIZE 1024
    5353
     54#define MAX_BACKLOG 128
     55
    5456/** Free ports pool start. */
    5557#define TCP_FREE_PORTS_START            1025
    … …  
    6062static int last_used_port = TCP_FREE_PORTS_START - 1;
    6163static socket_ports_t gsock;
     64
     65static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg);
    6266
    6367void tcp_sock_init(void)
    … …  
    9599{
    96100        tcp_sockdata_t *sock;
     101        socket_core_t *sock_core;
    97102        int sock_id;
    98103        int rc;
    … …  
    106111        }
    107112
     113        fibril_mutex_initialize(&sock->lock);
    108114        sock->client = client;
    109115        sock->laddr.ipv4 = TCP_IPV4_ANY;
     116        sock->lconn = NULL;
     117        sock->backlog = 0;
     118        list_initialize(&sock->ready);
    110119
    111120        sock_id = SOCKET_GET_SOCKET_ID(call);
    … …  
    115124                return;
    116125        }
     126
     127        sock_core = socket_cores_find(&client->sockets, sock_id);
     128        assert(sock_core != NULL);
     129        sock->sock_core = sock_core;
    117130
    118131        refresh_answer(&answer, NULL);
    … …  
    167180        socket_core_t *sock_core;
    168181        tcp_sockdata_t *socket;
     182        tcp_error_t trc;
     183        tcp_sock_t lsocket;
     184        tcp_sock_t fsocket;
     185        tcp_conn_t *conn;
     186        tcp_sock_lconn_t *lconn;
     187        int i;
    169188
    170189        log_msg(LVL_DEBUG, "tcp_sock_listen()");
    … …  
    177196                return;
    178197        }
     198
     199        if (backlog > MAX_BACKLOG)
     200                backlog = MAX_BACKLOG;
    179201
    180202        sock_core = socket_cores_find(&client->sockets, socket_id);
    … …  
    187209
    188210        /*
    189          * XXX We do not do anything and defer action to accept().
    190          * This is a slight difference in semantics, but most servers
    191          * would just listen() and immediately accept() in a loop.
    192          *
    193          * The only difference is that there is a window between
    194          * listen() and accept() or two accept()s where we refuse
    195          * connections.
     211         * Prepare @c backlog listening connections.
    196212         */
    197         (void)backlog;
    198         (void)socket;
    199 
     213        fibril_mutex_lock(&socket->lock);
     214
     215        socket->backlog = backlog;
     216        socket->lconn = calloc(sizeof(tcp_conn_t *), backlog);
     217        if (socket->lconn == NULL) {
     218                fibril_mutex_unlock(&socket->lock);
     219                async_answer_0(callid, ENOMEM);
     220                return;
     221        }
     222
     223        log_msg(LVL_DEBUG, " - open connections");
     224
     225        lsocket.addr.ipv4 = TCP_IPV4_ANY;
     226        lsocket.port = sock_core->port;
     227        fsocket.addr.ipv4 = TCP_IPV4_ANY;
     228        fsocket.port = TCP_PORT_ANY;
     229
     230        for (i = 0; i < backlog; i++) {
     231
     232                lconn = calloc(sizeof(tcp_sock_lconn_t), 1);
     233                if (lconn == NULL) {
     234                        /* XXX Clean up */
     235                        fibril_mutex_unlock(&socket->lock);
     236                        async_answer_0(callid, ENOMEM);
     237                        return;
     238                }
     239
     240                trc = tcp_uc_open(&lsocket, &fsocket, ap_passive,
     241                    tcp_open_nonblock, &conn);
     242                if (conn == NULL) {
     243                        /* XXX Clean up */
     244                        fibril_mutex_unlock(&socket->lock);
     245                        async_answer_0(callid, ENOMEM);
     246                        return;
     247                }
     248
     249                tcp_uc_set_cstate_cb(conn, tcp_sock_cstate_cb, lconn);
     250
     251                assert(trc == TCP_EOK);
     252                conn->name = (char *)"S";
     253
     254                lconn->conn = conn;
     255                lconn->socket = socket;
     256                link_initialize(&lconn->ready_list);
     257                socket->lconn[i] = lconn;
     258        }
     259
     260        fibril_mutex_unlock(&socket->lock);
    200261        async_answer_0(callid, EOK);
    201         log_msg(LVL_DEBUG, "tcp_sock_listen(): notify data\n");
    202         /* Push one accept notification to client's queue */
    203         tcp_sock_notify_aconn(sock_core);
    204262}
    205263
    … …  
    248306        }
    249307
     308        fibril_mutex_lock(&socket->lock);
     309
    250310        if (socket->laddr.ipv4 == TCP_IPV4_ANY) {
    251311                /* Find route to determine local IP address. */
    … …  
    254314                    (void **)&phdr, &phdr_len);
    255315                if (rc != EOK) {
     316                        fibril_mutex_unlock(&socket->lock);
    256317                        async_answer_0(callid, rc);
    257318                        log_msg(LVL_DEBUG, "tcp_transmit_connect: Failed to find route.");
    … …  
    269330        fsocket.port = uint16_t_be2host(addr->sin_port);
    270331
    271         trc = tcp_uc_open(&lsocket, &fsocket, ap_active, &socket->conn);
     332        trc = tcp_uc_open(&lsocket, &fsocket, ap_active, 0, &socket->conn);
    272333
    273334        if (socket->conn != NULL)
    274335                socket->conn->name = (char *)"C";
     336
     337        fibril_mutex_unlock(&socket->lock);
    275338
    276339        switch (trc) {
    … …  
    305368        tcp_sock_t fsocket;
    306369        tcp_conn_t *conn;
     370        tcp_conn_t *rconn;
     371        tcp_sock_lconn_t *lconn;
    307372        int rc;
    308373
    … …  
    319384
    320385        socket = (tcp_sockdata_t *)sock_core->specific_data;
     386        fibril_mutex_lock(&socket->lock);
    321387
    322388        log_msg(LVL_DEBUG, " - verify socket->conn");
    323389        if (socket->conn != NULL) {
     390                fibril_mutex_unlock(&socket->lock);
    324391                async_answer_0(callid, EINVAL);
    325392                return;
    326393        }
    327394
    328         log_msg(LVL_DEBUG, " - open connection");
     395        if (list_empty(&socket->ready)) {
     396                fibril_mutex_unlock(&socket->lock);
     397                async_answer_0(callid, ENOENT);
     398                return;
     399        }
     400
     401        lconn = list_get_instance(list_first(&socket->ready),
     402            tcp_sock_lconn_t, ready_list);
     403        list_remove(&lconn->ready_list);
     404
     405        conn = lconn->conn;
     406        tcp_uc_set_cstate_cb(conn, NULL, NULL);
     407
     408        /* Replenish listening connection */
    329409
    330410        lsocket.addr.ipv4 = TCP_IPV4_ANY;
    … …  
    333413        fsocket.port = TCP_PORT_ANY;
    334414
    335         trc = tcp_uc_open(&lsocket, &fsocket, ap_passive, &conn);
    336         if (conn != NULL)
    337                 conn->name = (char *)"S";
    338 
    339         log_msg(LVL_DEBUG, " - decode TCP return code");
    340 
    341         switch (trc) {
    342         case TCP_EOK:
    343                 rc = EOK;
    344                 break;
    345         case TCP_ERESET:
    346                 rc = ECONNABORTED;
    347                 break;
    348         default:
    349                 assert(false);
    350         }
    351 
    352         log_msg(LVL_DEBUG, " - check TCP return code");
    353         if (rc != EOK) {
    354                 async_answer_0(callid, rc);
    355                 return;
    356         }
     415        trc = tcp_uc_open(&lsocket, &fsocket, ap_passive, tcp_open_nonblock,
     416            &rconn);
     417        if (rconn == NULL) {
     418                /* XXX Clean up */
     419                fibril_mutex_unlock(&socket->lock);
     420                async_answer_0(callid, ENOMEM);
     421                return;
     422        }
     423
     424        tcp_uc_set_cstate_cb(rconn, tcp_sock_cstate_cb, lconn);
     425
     426        assert(trc == TCP_EOK);
     427        rconn->name = (char *)"S";
     428
     429        lconn->conn = rconn;
     430
     431        /* Allocate socket for accepted connection */
    357432
    358433        log_msg(LVL_DEBUG, "tcp_sock_accept(): allocate asocket\n");
    359434        asocket = calloc(sizeof(tcp_sockdata_t), 1);
    360435        if (asocket == NULL) {
     436                fibril_mutex_unlock(&socket->lock);
    361437                async_answer_0(callid, ENOMEM);
    362438                return;
    363439        }
    364440
     441        fibril_mutex_initialize(&asocket->lock);
    365442        asocket->client = client;
    366443        asocket->conn = conn;
    … …  
    369446        rc = socket_create(&client->sockets, client->sess, asocket, &asock_id);
    370447        if (rc != EOK) {
     448                fibril_mutex_unlock(&socket->lock);
    371449                async_answer_0(callid, rc);
    372450                return;
    … …  
    385463        answer_call(callid, asock_core->socket_id, &answer, 3);
    386464
    387         /* Push one accept notification to client's queue */
    388         tcp_sock_notify_aconn(sock_core);
    389 
    390465        /* Push one fragment notification to client's queue */
     466        log_msg(LVL_DEBUG, "tcp_sock_accept(): notify data\n");
    391467        tcp_sock_notify_data(asock_core);
    392         log_msg(LVL_DEBUG, "tcp_sock_accept(): notify aconn\n");
     468        fibril_mutex_unlock(&socket->lock);
    393469}
    394470
    … …  
    419495
    420496        socket = (tcp_sockdata_t *)sock_core->specific_data;
     497        fibril_mutex_lock(&socket->lock);
     498
    421499        if (socket->conn == NULL) {
     500                fibril_mutex_unlock(&socket->lock);
    422501                async_answer_0(callid, ENOTCONN);
    423502                return;
    … …  
    426505        for (index = 0; index < fragments; index++) {
    427506                if (!async_data_write_receive(&wcallid, &length)) {
     507                        fibril_mutex_unlock(&socket->lock);
    428508                        async_answer_0(callid, EINVAL);
    429509                        return;
    … …  
    435515                rc = async_data_write_finalize(wcallid, buffer, length);
    436516                if (rc != EOK) {
     517                        fibril_mutex_unlock(&socket->lock);
    437518                        async_answer_0(callid, rc);
    438519                        return;
    … …  
    459540
    460541                if (rc != EOK) {
     542                        fibril_mutex_unlock(&socket->lock);
    461543                        async_answer_0(callid, rc);
    462544                        return;
    … …  
    467549        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    468550        answer_call(callid, EOK, &answer, 2);
     551        fibril_mutex_unlock(&socket->lock);
    469552}
    470553
    … …  
    504587
    505588        socket = (tcp_sockdata_t *)sock_core->specific_data;
     589        fibril_mutex_lock(&socket->lock);
     590
    506591        if (socket->conn == NULL) {
     592                fibril_mutex_unlock(&socket->lock);
    507593                async_answer_0(callid, ENOTCONN);
    508594                return;
    … …  
    532618        log_msg(LVL_DEBUG, "**** tcp_uc_receive -> %d", rc);
    533619        if (rc != EOK) {
     620                fibril_mutex_unlock(&socket->lock);
    534621                async_answer_0(callid, rc);
    535622                return;
    … …  
    545632                log_msg(LVL_DEBUG, "addr read receive");
    546633                if (!async_data_read_receive(&rcallid, &addr_length)) {
     634                        fibril_mutex_unlock(&socket->lock);
    547635                        async_answer_0(callid, EINVAL);
    548636                        return;
    … …  
    555643                rc = async_data_read_finalize(rcallid, &addr, addr_length);
    556644                if (rc != EOK) {
     645                        fibril_mutex_unlock(&socket->lock);
    557646                        async_answer_0(callid, EINVAL);
    558647                        return;
    … …  
    562651        log_msg(LVL_DEBUG, "data read receive");
    563652        if (!async_data_read_receive(&rcallid, &length)) {
     653                fibril_mutex_unlock(&socket->lock);
    564654                async_answer_0(callid, EINVAL);
    565655                return;
    … …  
    580670        /* Push one fragment notification to client's queue */
    581671        tcp_sock_notify_data(sock_core);
     672        fibril_mutex_unlock(&socket->lock);
    582673}
    583674
    … …  
    603694
    604695        socket = (tcp_sockdata_t *)sock_core->specific_data;
     696        fibril_mutex_lock(&socket->lock);
    605697
    606698        if (socket->conn != NULL) {
    607699                trc = tcp_uc_close(socket->conn);
    608700                if (trc != TCP_EOK && trc != TCP_ENOTEXIST) {
     701                        fibril_mutex_unlock(&socket->lock);
    609702                        async_answer_0(callid, EBADF);
    610703                        return;
    … …  
    623716            tcp_free_sock_data);
    624717        if (rc != EOK) {
     718                fibril_mutex_unlock(&socket->lock);
    625719                async_answer_0(callid, rc);
    626720                return;
    627721        }
    628722
     723        fibril_mutex_unlock(&socket->lock);
    629724        async_answer_0(callid, EOK);
    630725}
    … …  
    640735        log_msg(LVL_DEBUG, "tcp_sock_setsockopt()");
    641736        async_answer_0(callid, ENOTSUP);
     737}
     738
     739/** Called when connection state changes. */
     740static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg)
     741{
     742        tcp_conn_status_t cstatus;
     743        tcp_sock_lconn_t *lconn = (tcp_sock_lconn_t *)arg;
     744        tcp_sockdata_t *socket = lconn->socket;
     745
     746        log_msg(LVL_DEBUG, "tcp_sock_cstate_cb()");
     747        fibril_mutex_lock(&socket->lock);
     748        assert(conn == lconn->conn);
     749
     750        tcp_uc_status(conn, &cstatus);
     751        if (cstatus.cstate != st_established) {
     752                fibril_mutex_unlock(&socket->lock);
     753                return;
     754        }
     755
     756        assert_link_not_used(&lconn->ready_list);
     757        list_append(&lconn->ready_list, &socket->ready);
     758
     759        log_msg(LVL_DEBUG, "tcp_sock_cstate_cb(): notify accept");
     760
     761        /* Push one accept notification to client's queue */
     762        tcp_sock_notify_aconn(socket->sock_core);
     763        fibril_mutex_unlock(&socket->lock);
    642764}
    643765

  • uspace/srv/net/tl/tcp/tcp_type.h

    r3819ce5 recf823a  
    152152} acpass_t;
    153153
    154 typedef struct tcp_conn {
     154typedef enum {
     155        tcp_open_nonblock = 1
     156} tcp_open_flags_t;
     157
     158typedef struct tcp_conn tcp_conn_t;
     159
     160/** Connection state change callback function */
     161typedef void (*tcp_cstate_cb_t)(tcp_conn_t *, void *);
     162
     163/** Connection */
     164struct tcp_conn {
    155165        char *name;
    156166        link_t link;
     167
     168        /** Connection state change callback function */
     169        tcp_cstate_cb_t cstate_cb;
     170        /** Argument to @c cstate_cb */
     171        void *cstate_cb_arg;
    157172
    158173        /** Connection identification (local and foreign socket) */
    … …  
    233248        /** Initial receive sequence number */
    234249        uint32_t irs;
    235 } tcp_conn_t;
    236 
    237 typedef struct {
    238         unsigned dummy;
     250};
     251
     252/** Data returned by Status user call */
     253typedef struct {
     254        /** Connection state */
     255        tcp_cstate_t cstate;
    239256} tcp_conn_status_t;
    240257
    … …  
    314331} tcp_client_t;
    315332
    316 typedef struct {
     333typedef struct tcp_sockdata {
     334        /** Lock */
     335        fibril_mutex_t lock;
     336        /** Socket core */
     337        socket_core_t *sock_core;
    317338        /** Client */
    318339        tcp_client_t *client;
    … …  
    321342        /** Local address */
    322343        netaddr_t laddr;
     344        /** Backlog size */
     345        int backlog;
     346        /** Array of listening connections, @c backlog elements */
     347        struct tcp_sock_lconn **lconn;
     348        /** List of connections (from lconn) that are ready to be accepted */
     349        list_t ready;
    323350} tcp_sockdata_t;
     351
     352typedef struct tcp_sock_lconn {
     353        tcp_conn_t *conn;
     354        tcp_sockdata_t *socket;
     355        int index;
     356        link_t ready_list;
     357} tcp_sock_lconn_t;
     358
    324359
    325360#endif

  • uspace/srv/net/tl/tcp/test.c

    r3819ce5 recf823a  
    6262        fsock.addr.ipv4 = 0x7f000001;
    6363        printf("S: User open...\n");
    64         tcp_uc_open(&lsock, &fsock, ap_passive, &conn);
     64        tcp_uc_open(&lsock, &fsock, ap_passive, 0, &conn);
    6565        conn->name = (char *) "S";
    6666
    … …  
    102102        async_usleep(1000*1000*3);
    103103        printf("C: User open...\n");
    104         tcp_uc_open(&lsock, &fsock, ap_active, &conn);
     104        tcp_uc_open(&lsock, &fsock, ap_active, 0, &conn);
    105105        conn->name = (char *) "C";
    106106

  • uspace/srv/net/tl/tcp/ucall.c

    r3819ce5 recf823a  
    5353 * @param fsock         Foreign socket
    5454 * @param acpass        Active/passive
     55 * @param oflags        Open flags
    5556 * @param conn          Connection
    5657 *
    … …  
    6566 */
    6667tcp_error_t tcp_uc_open(tcp_sock_t *lsock, tcp_sock_t *fsock, acpass_t acpass,
    67     tcp_conn_t **conn)
     68    tcp_open_flags_t oflags, tcp_conn_t **conn)
    6869{
    6970        tcp_conn_t *nconn;
    7071
    71         log_msg(LVL_DEBUG, "tcp_uc_open(%p, %p, %s, %p)",
     72        log_msg(LVL_DEBUG, "tcp_uc_open(%p, %p, %s, %s, %p)",
    7273            lsock, fsock, acpass == ap_active ? "active" : "passive",
    73             conn);
     74            oflags == tcp_open_nonblock ? "nonblock" : "none", conn);
    7475
    7576        nconn = tcp_conn_new(lsock, fsock);
    … …  
    7980                /* Synchronize (initiate) connection */
    8081                tcp_conn_sync(nconn);
     82        }
     83
     84        if (oflags == tcp_open_nonblock) {
     85                *conn = nconn;
     86                return TCP_EOK;
    8187        }
    8288
    … …  
    101107
    102108        *conn = nconn;
     109        log_msg(LVL_DEBUG, "tcp_uc_open -> %p", nconn);
    103110        return TCP_EOK;
    104111}
    … …  
    258265{
    259266        log_msg(LVL_DEBUG, "tcp_uc_status()");
     267        cstatus->cstate = conn->cstate;
    260268}
    261269
    … …  
    270278        log_msg(LVL_DEBUG, "tcp_uc_delete()");
    271279        tcp_conn_delete(conn);
     280}
     281
     282void tcp_uc_set_cstate_cb(tcp_conn_t *conn, tcp_cstate_cb_t cb, void *arg)
     283{
     284        log_msg(LVL_DEBUG, "tcp_uc_set_ctate_cb(%p, %p, %p)",
     285            conn, cb, arg);
     286
     287        conn->cstate_cb = cb;
     288        conn->cstate_cb_arg = arg;
    272289}
    273290

  • uspace/srv/net/tl/tcp/ucall.h

    r3819ce5 recf823a  
    4242 * User calls
    4343 */
    44 extern tcp_error_t tcp_uc_open(tcp_sock_t *, tcp_sock_t *, acpass_t, tcp_conn_t **);
     44extern tcp_error_t tcp_uc_open(tcp_sock_t *, tcp_sock_t *, acpass_t,
     45    tcp_open_flags_t, tcp_conn_t **);
    4546extern tcp_error_t tcp_uc_send(tcp_conn_t *, void *, size_t, xflags_t);
    4647extern tcp_error_t tcp_uc_receive(tcp_conn_t *, void *, size_t, size_t *, xflags_t *);
    … …  
    4950extern void tcp_uc_status(tcp_conn_t *, tcp_conn_status_t *);
    5051extern void tcp_uc_delete(tcp_conn_t *);
     52extern void tcp_uc_set_cstate_cb(tcp_conn_t *, tcp_cstate_cb_t, void *);
    5153
    5254/*
Note: See TracChangeset for help on using the changeset viewer.