Changes in / [c62a8275:f93ba6d] in mainline


Ignore:
Location:
uspace
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nic/nic.c

    rc62a8275 rf93ba6d  
    4949        nic_cable_state_t link_state;
    5050        nic_channel_mode_t duplex;
    51         nic_unicast_mode_t unicast_mode;
    52         nic_multicast_mode_t multicast_mode;
    53         nic_broadcast_mode_t broadcast_mode;
    5451        int speed;
    5552} nic_info_t;
    … …  
    6562        printf("\tduplex <half|full|simplex> - set duplex mode\n");
    6663        printf("\tauto - enable autonegotiation\n");
    67         printf("\tunicast <block|default|list|promisc> - set unicast receive filtering\n");
    68         printf("\tmulticast <block|list|promisc> - set multicast receive filtering\n");
    69         printf("\tbroadcast <block|allow> - block or allow incoming broadcast frames\n");
    7064}
    7165
    … …  
    151145        }
    152146
    153         rc = nic_unicast_get_mode(sess, &info->unicast_mode, 0, NULL, NULL);
    154         if (rc != EOK) {
    155                 printf("Error gettinc NIC unicast receive mode.\n");
    156                 rc = EIO;
    157                 goto error;
    158         }
    159 
    160         rc = nic_multicast_get_mode(sess, &info->multicast_mode, 0, NULL, NULL);
    161         if (rc != EOK) {
    162                 printf("Error gettinc NIC multicast receive mode.\n");
    163                 rc = EIO;
    164                 goto error;
    165         }
    166 
    167         rc = nic_broadcast_get_mode(sess, &info->broadcast_mode);
    168         if (rc != EOK) {
    169                 printf("Error gettinc NIC broadcast receive mode.\n");
    170                 rc = EIO;
    171                 goto error;
    172         }
    173147
    174148        return EOK;
    … …  
    193167        case NIC_CM_HALF_DUPLEX: return "half-duplex";
    194168        case NIC_CM_SIMPLEX: return "simplex";
    195         default: assert(false); return NULL;
    196         }
    197 }
    198 
    199 static const char *nic_unicast_mode_str(nic_unicast_mode_t mode)
    200 {
    201         switch (mode) {
    202         case NIC_UNICAST_UNKNOWN: return "unknown";
    203         case NIC_UNICAST_BLOCKED: return "blocked";
    204         case NIC_UNICAST_DEFAULT: return "default";
    205         case NIC_UNICAST_LIST: return "list";
    206         case NIC_UNICAST_PROMISC: return "promisc";
    207         default: assert(false); return NULL;
    208         }
    209 }
    210 
    211 static const char *nic_multicast_mode_str(nic_unicast_mode_t mode)
    212 {
    213         switch (mode) {
    214         case NIC_MULTICAST_UNKNOWN: return "unknown";
    215         case NIC_MULTICAST_BLOCKED: return "blocked";
    216         case NIC_MULTICAST_LIST: return "list";
    217         case NIC_MULTICAST_PROMISC: return "promisc";
    218         default: assert(false); return NULL;
    219         }
    220 }
    221 
    222 static const char *nic_broadcast_mode_str(nic_unicast_mode_t mode)
    223 {
    224         switch (mode) {
    225         case NIC_BROADCAST_UNKNOWN: return "unknown";
    226         case NIC_BROADCAST_BLOCKED: return "blocked";
    227         case NIC_BROADCAST_ACCEPTED: return "accepted";
    228169        default: assert(false); return NULL;
    229170        }
    … …  
    293234                printf("\tLink state: %s\n",
    294235                    nic_link_state_str(nic_info.link_state));
    295                 printf("\tUnicast receive mode: %s\n",
    296                     nic_unicast_mode_str(nic_info.unicast_mode));
    297                 printf("\tMulticast receive mode: %s\n",
    298                     nic_multicast_mode_str(nic_info.multicast_mode));
    299                 printf("\tBroadcast receive mode: %s\n",
    300                     nic_broadcast_mode_str(nic_info.broadcast_mode));
    301236
    302237                if (nic_info.link_state == NIC_CS_PLUGGED) {
    … …  
    434369
    435370        return nic_set_address(sess, &addr);
    436 }
    437 
    438 static int nic_set_rx_unicast(int i, char *str)
    439 {
    440         async_sess_t *sess;
    441 
    442         sess = get_nic_by_index(i);
    443         if (sess == NULL) {
    444                 printf("Specified NIC doesn't exist or cannot connect to it.\n");
    445                 return EINVAL;
    446         }
    447 
    448         if (!str_cmp(str, "block")) {
    449                 nic_unicast_set_mode(sess, NIC_UNICAST_BLOCKED, NULL, 0);
    450                 return EOK;
    451         }
    452 
    453         if (!str_cmp(str, "default")) {
    454                 nic_unicast_set_mode(sess, NIC_UNICAST_DEFAULT, NULL, 0);
    455                 return EOK;
    456         }
    457 
    458         if (!str_cmp(str, "list")) {
    459                 nic_unicast_set_mode(sess, NIC_UNICAST_LIST, NULL, 0);
    460                 return EOK;
    461         }
    462 
    463         if (!str_cmp(str, "promisc")) {
    464                 nic_unicast_set_mode(sess, NIC_UNICAST_PROMISC, NULL, 0);
    465                 return EOK;
    466         }
    467 
    468 
    469         printf("Invalid pameter - should be one of: block, default, promisc\n");
    470         return EINVAL;
    471 }
    472 
    473 static int nic_set_rx_multicast(int i, char *str)
    474 {
    475         async_sess_t *sess;
    476 
    477         sess = get_nic_by_index(i);
    478         if (sess == NULL) {
    479                 printf("Specified NIC doesn't exist or cannot connect to it.\n");
    480                 return EINVAL;
    481         }
    482 
    483         if (!str_cmp(str, "block")) {
    484                 nic_multicast_set_mode(sess, NIC_MULTICAST_BLOCKED, NULL, 0);
    485                 return EOK;
    486         }
    487 
    488         if (!str_cmp(str, "list")) {
    489                 nic_multicast_set_mode(sess, NIC_MULTICAST_LIST, NULL, 0);
    490                 return EOK;
    491         }
    492 
    493         if (!str_cmp(str, "promisc")) {
    494                 nic_multicast_set_mode(sess, NIC_MULTICAST_PROMISC, NULL, 0);
    495                 return EOK;
    496         }
    497 
    498         printf("Invalid pameter - should be one of: block, promisc\n");
    499         return EINVAL;
    500 }
    501 
    502 static int nic_set_rx_broadcast(int i, char *str)
    503 {
    504         async_sess_t *sess;
    505 
    506         sess = get_nic_by_index(i);
    507         if (sess == NULL) {
    508                 printf("Specified NIC doesn't exist or cannot connect to it.\n");
    509                 return EINVAL;
    510         }
    511 
    512         if (!str_cmp(str, "block")) {
    513                 nic_broadcast_set_mode(sess, NIC_BROADCAST_BLOCKED);
    514                 return EOK;
    515         }
    516 
    517         if (!str_cmp(str, "accept")) {
    518                 nic_broadcast_set_mode(sess, NIC_BROADCAST_ACCEPTED);
    519                 return EOK;
    520         }
    521 
    522         printf("Invalid pameter - should be 'block' or 'accept'\n");
    523         return EINVAL;
    524371}
    525372
    … …  
    553400                        return nic_set_autoneg(index);
    554401
    555                 if (!str_cmp(argv[2], "unicast"))
    556                         return nic_set_rx_unicast(index, argv[3]);
    557 
    558                 if (!str_cmp(argv[2], "multicast"))
    559                         return nic_set_rx_multicast(index, argv[3]);
    560 
    561                 if (!str_cmp(argv[2], "broadcast"))
    562                         return nic_set_rx_broadcast(index, argv[3]);
    563 
    564402        } else {
    565403                printf(NAME ": Invalid argument.\n");

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

    rc62a8275 rf93ba6d  
    2727 */
    2828
     29#define _DDF_DATA_IMPLANT
     30
    2931#include <assert.h>
    3032#include <errno.h>
    … …  
    328330}
    329331
    330 static void rtl8169_dev_cleanup(ddf_dev_t *dev)
    331 {
    332         assert(dev);
    333 
    334         if (ddf_dev_data_get(dev))
    335                 nic_unbind_and_destroy(dev);
    336 }
    337 
    338332static int rtl8169_dev_initialize(ddf_dev_t *dev)
    339333{
    … …  
    357351failed:
    358352        ddf_msg(LVL_ERROR, "The device initialization failed");
    359         rtl8169_dev_cleanup(dev);
     353//      rtl8139_dev_cleanup(dev);
    360354        return ret;
    361355
    … …  
    445439        nic_set_ddf_fun(nic_data, fun);
    446440        ddf_fun_set_ops(fun, &rtl8169_dev_ops);
     441//      ddf_fun_data_implant(fun, nic_data);
    447442
    448443        rc = ddf_fun_bind(fun);
    … …  
    472467err_pio:
    473468err_destroy:
    474         rtl8169_dev_cleanup(dev);
     469        //rtl8169_dev_cleanup(dev);
    475470        return rc;
    476471
    … …  
    738733        /* Configure Receive Control Register */
    739734        uint32_t rcr = pio_read_32(rtl8169->regs + RCR);
    740         rtl8169->rcr_ucast = RCR_ACCEPT_PHYS_MATCH;
    741         rcr |= RCR_ACCEPT_PHYS_MATCH | RCR_ACCEPT_ERROR | RCR_ACCEPT_RUNT;
     735        rcr |= RCR_ACCEPT_ALL_PHYS | RCR_ACCEPT_PHYS_MATCH \
     736            | RCR_ACCEPT_BROADCAST | RCR_ACCEPT_ERROR \
     737            | RCR_ACCEPT_RUNT;
    742738        pio_write_32(rtl8169->regs + RCR, rcr);
    743739        pio_write_16(rtl8169->regs + RMS, BUFFER_SIZE);
     740
     741        ddf_msg(LVL_NOTE, "RCR: 0x%08x", pio_read_32(rtl8169->regs + RCR));
     742
    744743
    745744        pio_write_16(rtl8169->regs + IMR, 0xffff);
    … …  
    794793}
    795794
    796 /** Notify NIC framework about HW filtering state when promisc mode was disabled
    797  *
    798  *  @param nic_data     The NIC data
    799  *  @param mcast_mode   Current multicast mode
    800  *  @param was_promisc  Sign if the promiscuous mode was active before disabling
    801  */
    802 inline static void rtl8169_rcx_promics_rem(nic_t *nic_data,
    803     nic_multicast_mode_t mcast_mode, uint8_t was_promisc)
    804 {
    805         assert(nic_data);
    806 
    807         if (was_promisc != 0) {
    808                 if (mcast_mode == NIC_MULTICAST_LIST)
    809                         nic_report_hw_filtering(nic_data, 1, 0, -1);
    810                 else
    811                         nic_report_hw_filtering(nic_data, 1, 1, -1);
    812         } else {
    813                 nic_report_hw_filtering(nic_data, 1, -1, -1);
    814         }
    815 }
    816 
    817795static int rtl8169_unicast_set(nic_t *nic_data, nic_unicast_mode_t mode,
    818796    const nic_address_t *addr, size_t addr_count)
    819797{
    820         rtl8169_t *rtl8169 = nic_get_specific(nic_data);
    821         uint32_t rcr = pio_read_32(rtl8169->regs + RCR);
    822         uint8_t was_promisc = rcr & RCR_ACCEPT_ALL_PHYS;
    823         nic_multicast_mode_t mcast_mode;
    824 
    825         nic_query_multicast(nic_data, &mcast_mode, 0, NULL, NULL);
    826 
    827         ddf_msg(LVL_DEBUG, "Unicast RX filter mode: %d", mode);
    828 
    829 
    830         switch (mode) {
    831         case NIC_UNICAST_BLOCKED:
    832                 rtl8169->rcr_ucast = 0;
    833                 rtl8169_rcx_promics_rem(nic_data, mcast_mode, was_promisc);
    834                 break;
    835         case NIC_UNICAST_DEFAULT:
    836                 rtl8169->rcr_ucast = RCR_ACCEPT_PHYS_MATCH;
    837                 rtl8169_rcx_promics_rem(nic_data, mcast_mode, was_promisc);
    838                 break;
    839         case NIC_UNICAST_LIST:
    840                 rtl8169->rcr_ucast = RCR_ACCEPT_PHYS_MATCH | RCR_ACCEPT_ALL_PHYS;
    841 
    842                 if (mcast_mode == NIC_MULTICAST_PROMISC)
    843                         nic_report_hw_filtering(nic_data, 0, 1, -1);
    844                 else
    845                         nic_report_hw_filtering(nic_data, 0, 0, -1);
    846                 break;
    847         case NIC_UNICAST_PROMISC:
    848                 rtl8169->rcr_ucast = RCR_ACCEPT_PHYS_MATCH | RCR_ACCEPT_ALL_PHYS;
    849 
    850                 if (mcast_mode == NIC_MULTICAST_PROMISC)
    851                         nic_report_hw_filtering(nic_data, 1, 1, -1);
    852                 else
    853                         nic_report_hw_filtering(nic_data, 1, 0, -1);
    854                 break;
    855         default:
    856                 return ENOTSUP;
    857         }
    858 
    859         fibril_mutex_lock(&rtl8169->rx_lock);
    860 
    861         rcr &= ~(RCR_ACCEPT_PHYS_MATCH | RCR_ACCEPT_ALL_PHYS);
    862         pio_write_32(rtl8169->regs + RCR, rcr | rtl8169->rcr_ucast | rtl8169->rcr_mcast);
    863         ddf_msg(LVL_DEBUG, "new RCR value: 0x%08x", rcr | rtl8169->rcr_ucast | rtl8169->rcr_mcast);
    864 
    865         fibril_mutex_unlock(&rtl8169->rx_lock);
    866798        return EOK;
    867799}
    … …  
    870802    const nic_address_t *addr, size_t addr_count)
    871803{
    872         rtl8169_t *rtl8169 = nic_get_specific(nic_data);
    873         uint32_t rcr = pio_read_32(rtl8169->regs + RCR);
    874         uint64_t mask;
    875 
    876         ddf_msg(LVL_DEBUG, "Multicast RX filter mode: %d", mode);
    877 
    878         switch (mode) {
    879         case NIC_MULTICAST_BLOCKED:
    880                 rtl8169->rcr_mcast = 0;
    881                 if ((rtl8169->rcr_ucast & RCR_ACCEPT_ALL_PHYS) != 0)
    882                         nic_report_hw_filtering(nic_data, -1, 0, -1);
    883                 else
    884                         nic_report_hw_filtering(nic_data, -1, 1, -1);
    885                 break;
    886         case NIC_MULTICAST_LIST:
    887                 mask = nic_mcast_hash(addr, addr_count);
    888                 pio_write_32(rtl8169->regs + MAR0, (uint32_t)mask);
    889                 pio_write_32(rtl8169->regs + MAR0 + 4, (uint32_t)(mask >> 32));
    890                 rtl8169->rcr_mcast = RCR_ACCEPT_MULTICAST;
    891                 nic_report_hw_filtering(nic_data, -1, 0, -1);
    892                 break;
    893         case NIC_MULTICAST_PROMISC:
    894                 pio_write_32(rtl8169->regs + MAR0, 0xffffffffULL);
    895                 pio_write_32(rtl8169->regs + MAR0 + 4, (uint32_t)(0xffffffffULL >> 32));
    896                 rtl8169->rcr_mcast = RCR_ACCEPT_MULTICAST;
    897                 nic_report_hw_filtering(nic_data, -1, 1, -1);
    898                 break;
    899         default:
    900                 return ENOTSUP;
    901         }
    902 
    903         fibril_mutex_lock(&rtl8169->rx_lock);
    904 
    905         rcr &= ~(RCR_ACCEPT_PHYS_MATCH | RCR_ACCEPT_ALL_PHYS);
    906         pio_write_32(rtl8169->regs + RCR, rcr | rtl8169->rcr_ucast | rtl8169->rcr_mcast);
    907         ddf_msg(LVL_DEBUG, "new RCR value: 0x%08x", rcr | rtl8169->rcr_ucast | rtl8169->rcr_mcast);
    908 
    909         fibril_mutex_unlock(&rtl8169->rx_lock);
    910804        return EOK;
    911805}
    … …  
    913807static int rtl8169_broadcast_set(nic_t *nic_data, nic_broadcast_mode_t mode)
    914808{
    915         rtl8169_t *rtl8169 = nic_get_specific(nic_data);
    916        
    917         /* Configure Receive Control Register */
    918         uint32_t rcr = pio_read_32(rtl8169->regs + RCR);
    919 
    920         ddf_msg(LVL_DEBUG, "Broadcast RX filter mode: %d", mode);
    921 
    922         switch (mode) {
    923         case NIC_BROADCAST_BLOCKED:
    924                 rcr &= RCR_ACCEPT_BROADCAST;
    925                 break;
    926         case NIC_BROADCAST_ACCEPTED:
    927                 rcr |= RCR_ACCEPT_BROADCAST;
    928                 break;
    929         default:
    930                 return ENOTSUP;
    931         }
    932 
    933         pio_write_32(rtl8169->regs + RCR, rcr);
    934         ddf_msg(LVL_DEBUG," new RCR value: 0x%08x", rcr);
    935 
    936809        return EOK;
    937810}
    … …  
    943816        rtl8169_t *rtl8169 = nic_get_specific(nic_data);
    944817        rtl8169_descr_t *descr;
    945         int sent = 0;
    946 
    947         ddf_msg(LVL_DEBUG, "rtl8169_transmit_done()");
     818
     819        ddf_msg(LVL_NOTE, "rtl8169_transmit_done()");
    948820
    949821        fibril_mutex_lock(&rtl8169->tx_lock);
    … …  
    956828                descr->control &= (~CONTROL_OWN);
    957829                write_barrier();
    958                 ddf_msg(LVL_DEBUG, "TX status for descr %d: 0x%08x", tail, descr->control);
     830                ddf_msg(LVL_NOTE, "TX status for descr %d: 0x%08x", tail, descr->control);
    959831       
    960832                tail = (tail + 1) % TX_BUFFERS_COUNT;
    961                 sent++;
    962         }
    963 
    964         if (sent != 0)
    965                 nic_set_tx_busy(nic_data, 0);
     833        }
    966834
    967835        rtl8169->tx_tail = tail;
    … …  
    981849        int frame_size;
    982850
    983         ddf_msg(LVL_DEBUG, "rtl8169_receive_done()");
     851        ddf_msg(LVL_NOTE, "rtl8169_receive_done()");
    984852
    985853        fibril_mutex_lock(&rtl8169->rx_lock);
    … …  
    994862
    995863                if (descr->control & RXSTATUS_RES) {
    996                         ddf_msg(LVL_WARN, "error at slot %d: 0x%08x\n", tail, descr->control);
     864                        ddf_msg(LVL_NOTE, "error at slot %d: 0x%08x\n", tail, descr->control);
    997865                        tail = (tail + 1) % RX_BUFFERS_COUNT;
    998866                        continue;
    … …  
    1003871               
    1004872                if (descr->control & CONTROL_LS) {
    1005                         ddf_msg(LVL_DEBUG, "received message at slot %d, control 0x%08x", tail, descr->control);
     873
     874                        ddf_msg(LVL_NOTE, "received message at slot %d, control 0x%08x", tail, descr->control);
    1006875
    1007876                        if (fsidx != tail)
    … …  
    1038907        rtl8169_t *rtl8169 = nic_get_specific(nic_data);
    1039908
    1040         ddf_msg(LVL_DEBUG, "rtl8169_irq_handler(): isr=0x%04x", isr);
     909        ddf_msg(LVL_NOTE, "rtl8169_irq_handler(): isr=0x%04x", isr);
    1041910        pio_write_16(rtl8169->regs + IMR, 0xffff);
    1042911
    … …  
    1094963        fibril_mutex_lock(&rtl8169->tx_lock);
    1095964
    1096         ddf_msg(LVL_DEBUG, "send_frame: size: %zu, tx_head=%d tx_tail=%d",
     965        ddf_msg(LVL_NOTE, "send_frame: size: %zu, tx_head=%d tx_tail=%d",
    1097966            size, rtl8169->tx_head, rtl8169->tx_tail);
    1098967
    … …  
    1117986        prev = &rtl8169->tx_ring[(head - 1) % TX_BUFFERS_COUNT];
    1118987
    1119         ddf_msg(LVL_DEBUG, "current_descr=%p, prev_descr=%p", descr, prev);
     988        ddf_msg(LVL_NOTE, "current_descr=%p, prev_descr=%p", descr, prev);
    1120989
    1121990        descr->control = CONTROL_OWN | CONTROL_FS | CONTROL_LS;

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

    rc62a8275 rf93ba6d  
    8686        size_t tx_used;
    8787
    88         /** Receive Control Register masks */
    89         uint32_t rcr_ucast;
    90         uint32_t rcr_mcast;
    91 
    9288        /** Lock for receiver */
    9389        fibril_mutex_t rx_lock;

  • uspace/lib/c/generic/iplink.c

    rc62a8275 rf93ba6d  
    171171}
    172172
    173 int iplink_set_mac48(iplink_t *iplink, addr48_t mac)
    174 {
    175         async_exch_t *exch = async_exchange_begin(iplink->sess);
    176        
    177         ipc_call_t answer;
    178         aid_t req = async_send_0(exch, IPLINK_GET_MAC48, &answer);
    179        
    180         int rc = async_data_read_start(exch, mac, sizeof(addr48_t));
    181        
    182         loc_exchange_end(exch);
    183        
    184         if (rc != EOK) {
    185                 async_forget(req);
    186                 return rc;
    187         }
    188        
    189         sysarg_t retval;
    190         async_wait_for(req, &retval);
    191        
    192         return (int) retval;
    193 }
    194 
    195 
    196173int iplink_addr_add(iplink_t *iplink, inet_addr_t *addr)
    197174{
    … …  
    253230        free(sdu.data);
    254231        async_answer_0(iid, rc);
    255 }
    256 
    257 static void iplink_ev_change_addr(iplink_t *iplink, ipc_callid_t iid,
    258     ipc_call_t *icall)
    259 {
    260         addr48_t *addr;
    261         size_t size;
    262        
    263         int rc = async_data_write_accept((void **)&addr, false,
    264             sizeof(addr48_t), sizeof(addr48_t), 0, &size);
    265         if (rc != EOK) {
    266                 async_answer_0(iid, rc);
    267                 return;
    268         }
    269 
    270         rc = iplink->ev_ops->change_addr(iplink, *addr);
    271         free(addr);
    272         async_answer_0(iid, EOK);
    273232}
    274233
    … …  
    290249                        iplink_ev_recv(iplink, callid, &call);
    291250                        break;
    292                 case IPLINK_EV_CHANGE_ADDR:
    293                         iplink_ev_change_addr(iplink, callid, &call);
    294251                default:
    295252                        async_answer_0(callid, ENOTSUP);

  • uspace/lib/c/generic/iplink_srv.c

    rc62a8275 rf93ba6d  
    8181}
    8282
    83 static void iplink_set_mac48_srv(iplink_srv_t *srv, ipc_callid_t iid,
    84     ipc_call_t *icall)
    85 {
    86         int rc;
    87         size_t size;
    88         addr48_t mac;
    89         ipc_callid_t callid;
    90 
    91         rc = async_data_write_receive(&callid, &size);
    92         if (rc != EOK) {
    93                 async_answer_0(callid, (sysarg_t) rc);
    94                 async_answer_0(iid, (sysarg_t) rc);
    95         }
    96 
    97         rc = srv->ops->set_mac48(srv, &mac);
    98         if (rc != EOK) {
    99                 async_answer_0(iid, rc);
    100                 return;
    101         }
    102        
    103         rc = async_data_read_finalize(callid, &mac, sizeof(addr48_t));
    104         if (rc != EOK)
    105                 async_answer_0(callid, rc);
    106        
    107         async_answer_0(iid, (sysarg_t) rc);
    108 }
    109 
    11083static void iplink_addr_add_srv(iplink_srv_t *srv, ipc_callid_t iid,
    11184    ipc_call_t *icall)
    … …  
    279252                        iplink_get_mac48_srv(srv, callid, &call);
    280253                        break;
    281                 case IPLINK_SET_MAC48:
    282                         iplink_set_mac48_srv(srv, callid, &call);
    283                         break;
    284254                case IPLINK_SEND:
    285255                        iplink_send_srv(srv, callid, &call);
    … …  
    330300}
    331301
    332 int iplink_ev_change_addr(iplink_srv_t *srv, addr48_t *addr)
    333 {
    334         if (srv->client_sess == NULL)
    335                 return EIO;
    336        
    337         async_exch_t *exch = async_exchange_begin(srv->client_sess);
    338        
    339         ipc_call_t answer;
    340         aid_t req = async_send_0(exch, IPLINK_EV_CHANGE_ADDR, &answer);
    341        
    342         int rc = async_data_write_start(exch, addr, sizeof(addr48_t));
    343         async_exchange_end(exch);
    344        
    345         if (rc != EOK) {
    346                 async_forget(req);
    347                 return rc;
    348         }
    349        
    350         sysarg_t retval;
    351         async_wait_for(req, &retval);
    352         if (retval != EOK)
    353                 return retval;
    354        
    355         return EOK;
    356 }
    357 
    358302/** @}
    359303 */

  • uspace/lib/c/include/inet/iplink.h

    rc62a8275 rf93ba6d  
    7878typedef struct iplink_ev_ops {
    7979        int (*recv)(iplink_t *, iplink_recv_sdu_t *, ip_ver_t);
    80         int (*change_addr)(iplink_t *, addr48_t);
    8180} iplink_ev_ops_t;
    8281
    … …  
    8988extern int iplink_get_mtu(iplink_t *, size_t *);
    9089extern int iplink_get_mac48(iplink_t *, addr48_t *);
    91 extern int iplink_set_mac48(iplink_t *, addr48_t);
    9290
    9391#endif

  • uspace/lib/c/include/inet/iplink_srv.h

    rc62a8275 rf93ba6d  
    5959        int (*get_mtu)(iplink_srv_t *, size_t *);
    6060        int (*get_mac48)(iplink_srv_t *, addr48_t *);
    61         int (*set_mac48)(iplink_srv_t *, addr48_t *);
    6261        int (*addr_add)(iplink_srv_t *, inet_addr_t *);
    6362        int (*addr_remove)(iplink_srv_t *, inet_addr_t *);
    … …  
    6867extern int iplink_conn(ipc_callid_t, ipc_call_t *, void *);
    6968extern int iplink_ev_recv(iplink_srv_t *, iplink_recv_sdu_t *, ip_ver_t);
    70 extern int iplink_ev_change_addr(iplink_srv_t *, addr48_t *);
    7169
    7270#endif

  • uspace/lib/c/include/ipc/iplink.h

    rc62a8275 rf93ba6d  
    4141        IPLINK_GET_MTU = IPC_FIRST_USER_METHOD,
    4242        IPLINK_GET_MAC48,
    43         IPLINK_SET_MAC48,
    4443        IPLINK_SEND,
    4544        IPLINK_SEND6,
    … …  
    4948
    5049typedef enum {
    51         IPLINK_EV_RECV = IPC_FIRST_USER_METHOD,
    52         IPLINK_EV_CHANGE_ADDR,
     50        IPLINK_EV_RECV = IPC_FIRST_USER_METHOD
    5351} iplink_event_t;
    5452

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

    rc62a8275 rf93ba6d  
    4747#include <ops/nic.h>
    4848#include <errno.h>
     49
     50#include <io/log.h>
    4951
    5052#include "nic_driver.h"
    … …  
    436438                int rc = nic_ev_addr_changed(nic_data->client_session,
    437439                    address);
     440                log_msg(LOG_DEFAULT, LVL_WARN, "rc=%d", rc);
    438441
    439442                if (rc != EOK) {

  • uspace/srv/net/ethip/ethip.c

    rc62a8275 rf93ba6d  
    5959static int ethip_get_mtu(iplink_srv_t *srv, size_t *mtu);
    6060static int ethip_get_mac48(iplink_srv_t *srv, addr48_t *mac);
    61 static int ethip_set_mac48(iplink_srv_t *srv, addr48_t *mac);
    6261static int ethip_addr_add(iplink_srv_t *srv, inet_addr_t *addr);
    6362static int ethip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr);
    … …  
    7271        .get_mtu = ethip_get_mtu,
    7372        .get_mac48 = ethip_get_mac48,
    74         .set_mac48 = ethip_set_mac48,
    7573        .addr_add = ethip_addr_add,
    7674        .addr_remove = ethip_addr_remove
    … …  
    286284}
    287285
    288 static int ethip_set_mac48(iplink_srv_t *srv, addr48_t *mac)
    289 {
    290         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_set_mac48()");
    291        
    292         ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
    293         addr48(*mac, nic->mac_addr);
    294        
    295         return EOK;
    296 }
    297 
    298286static int ethip_addr_add(iplink_srv_t *srv, inet_addr_t *addr)
    299287{

  • uspace/srv/net/ethip/ethip_nic.c

    rc62a8275 rf93ba6d  
    245245            addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
    246246
    247         memcpy(&nic->mac_addr, addr, sizeof(nic->mac_addr));
    248 
    249         rc = iplink_ev_change_addr(&nic->iplink, &nic->mac_addr);
    250         if (rc != EOK) {
    251                 log_msg(LOG_DEFAULT, LVL_DEBUG, "iplink_ev_change_addr() failed");
    252                 return;
    253         }
    254 
    255247        free(addr);
    256248        async_answer_0(callid, EOK);
    … …  
    317309                        break;
    318310                default:
    319                         log_msg(LOG_DEFAULT, LVL_DEBUG, "unknown IPC method: %" PRIun, IPC_GET_IMETHOD(call));
     311                        log_msg(LOG_DEFAULT, LVL_DEBUG, "unknown IPC method: %d", (int) IPC_GET_IMETHOD(call));
    320312                        async_answer_0(callid, ENOTSUP);
    321313                }

  • uspace/srv/net/inetsrv/inet_link.c

    rc62a8275 rf93ba6d  
    5555
    5656static int inet_iplink_recv(iplink_t *, iplink_recv_sdu_t *, ip_ver_t);
    57 static int inet_iplink_change_addr(iplink_t *, addr48_t);
    5857static inet_link_t *inet_link_get_by_id_locked(sysarg_t);
    5958
    6059static iplink_ev_ops_t inet_iplink_ev_ops = {
    61         .recv = inet_iplink_recv,
    62         .change_addr = inet_iplink_change_addr,
     60        .recv = inet_iplink_recv
    6361};
    6462
    … …  
    112110       
    113111        return rc;
    114 }
    115 
    116 static int inet_iplink_change_addr(iplink_t *iplink, addr48_t mac)
    117 {
    118         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_iplink_change_addr(): "
    119             "new addr=%02x:%02x:%02x:%02x:%02x:%02x",
    120             mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
    121 
    122         list_foreach(inet_links, link_list, inet_link_t, ilink) {
    123                 if (ilink->sess == iplink->sess)
    124                         memcpy(&ilink->mac, mac, sizeof(addr48_t));
    125         }
    126 
    127         return EOK;
    128112}
    129113
Note: See TracChangeset for help on using the changeset viewer.