Changes in / [c38e417:eaa0c3f] in mainline


Ignore:
Location:
uspace
Files:
2 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/device/nic.c

    rc38e417 reaa0c3f  
    7373}
    7474
    75 /** Create callback connection from NIC service
    76  *
    77  * @param[in] dev_sess
     75/** Connect the driver to the NET and NIL services
     76 *
     77 * @param[in] dev_sess
     78 * @param[in] nil_service Service identifier for the NIL service
    7879 * @param[in] device_id
    7980 *
    … …  
    8182 *
    8283 */
    83 int nic_callback_create(async_sess_t *dev_sess, nic_device_id_t device_id,
    84     async_client_conn_t cfun, void *carg)
    85 {
    86         ipc_call_t answer;
    87         int rc;
    88         sysarg_t retval;
    89        
    90         async_exch_t *exch = async_exchange_begin(dev_sess);
    91         aid_t req = async_send_2(exch, DEV_IFACE_ID(NIC_DEV_IFACE),
    92             NIC_CALLBACK_CREATE, device_id, &answer);
    93        
    94         rc = async_connect_to_me(exch, 0, 0, 0, cfun, carg);
    95         if (rc != EOK) {
    96                 async_wait_for(req, NULL);
    97                 return rc;
    98         }
    99         async_exchange_end(exch);
    100        
    101         async_wait_for(req, &retval);
    102         return (int) retval;
     84int nic_connect_to_nil(async_sess_t *dev_sess, services_t nil_service,
     85    nic_device_id_t device_id)
     86{
     87        async_exch_t *exch = async_exchange_begin(dev_sess);
     88        int rc = async_req_3_0(exch, DEV_IFACE_ID(NIC_DEV_IFACE),
     89            NIC_CONNECT_TO_NIL, nil_service, device_id);
     90        async_exchange_end(exch);
     91       
     92        return rc;
    10393}
    10494

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

    rc38e417 reaa0c3f  
    3939#include <net/device.h>
    4040#include <net/packet.h>
    41 #include <ipc/common.h>
    4241#include <ipc/services.h>
    4342
    4443typedef enum {
    4544        NIC_SEND_MESSAGE = 0,
    46         NIC_CALLBACK_CREATE,
     45        NIC_CONNECT_TO_NIL,
    4746        NIC_GET_STATE,
    4847        NIC_SET_STATE,
    … …  
    8685} nic_funcs_t;
    8786
    88 typedef enum {
    89         NIC_EV_ADDR_CHANGED = IPC_FIRST_USER_METHOD,
    90         NIC_EV_RECEIVED,
    91         NIC_EV_DEVICE_STATE
    92 } nic_event_t;
    93 
    9487extern int nic_send_frame(async_sess_t *, void *, size_t);
    95 extern int nic_callback_create(async_sess_t *, nic_device_id_t,
    96     async_client_conn_t, void *);
     88extern int nic_connect_to_nil(async_sess_t *, services_t, nic_device_id_t);
    9789extern int nic_get_state(async_sess_t *, nic_device_state_t *);
    9890extern int nic_set_state(async_sess_t *, nic_device_state_t);

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

    rc38e417 reaa0c3f  
    4646         */
    4747        NET_NIL_DEVICE = NET_NIL_FIRST,
     48        /** New device state message.
     49         * @see nil_device_state_msg()
     50         */
     51        NET_NIL_DEVICE_STATE,
     52        /** Received packet queue message.
     53         * @see nil_received_msg()
     54         */
     55        NET_NIL_RECEIVED,
    4856        /** Send packet queue message.
    4957         * @see nil_send_msg()
    … …  
    6169         * @see nil_get_broadcast_addr()
    6270         */
    63         NET_NIL_BROADCAST_ADDR
     71        NET_NIL_BROADCAST_ADDR,
     72        /** Device has changed address
     73         * @see nil_addr_changed_msg()
     74         */
     75        NET_NIL_ADDR_CHANGED
    6476} nil_messages;
    6577

  • uspace/lib/drv/generic/remote_nic.c

    rc38e417 reaa0c3f  
    6363}
    6464
    65 static void remote_nic_callback_create(ddf_fun_t *dev, void *iface,
    66     ipc_callid_t callid, ipc_call_t *call)
    67 {
    68         nic_iface_t *nic_iface = (nic_iface_t *) iface;
    69         assert(nic_iface->callback_create);
    70        
    71         nic_device_id_t device_id = (nic_device_id_t) IPC_GET_ARG2(*call);
    72        
    73         int rc = nic_iface->callback_create(dev, device_id);
     65static void remote_nic_connect_to_nil(ddf_fun_t *dev, void *iface,
     66    ipc_callid_t callid, ipc_call_t *call)
     67{
     68        nic_iface_t *nic_iface = (nic_iface_t *) iface;
     69        assert(nic_iface->connect_to_nil);
     70       
     71        services_t nil_service = (services_t) IPC_GET_ARG2(*call);
     72        nic_device_id_t device_id = (nic_device_id_t) IPC_GET_ARG3(*call);
     73       
     74        int rc = nic_iface->connect_to_nil(dev, nil_service, device_id);
    7475        async_answer_0(callid, rc);
    7576}
    … …  
    12021203static remote_iface_func_ptr_t remote_nic_iface_ops[] = {
    12031204        &remote_nic_send_frame,
    1204         &remote_nic_callback_create,
     1205        &remote_nic_connect_to_nil,
    12051206        &remote_nic_get_state,
    12061207        &remote_nic_set_state,

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

    rc38e417 reaa0c3f  
    4646        /** Mandatory methods */
    4747        int (*send_frame)(ddf_fun_t *, void *, size_t);
    48         int (*callback_create)(ddf_fun_t *, nic_device_id_t);
     48        int (*connect_to_nil)(ddf_fun_t *, services_t, nic_device_id_t);
    4949        int (*get_state)(ddf_fun_t *, nic_device_state_t *);
    5050        int (*set_state)(ddf_fun_t *, nic_device_state_t);

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

    rc38e417 reaa0c3f  
    6262extern int nil_device_req(async_sess_t *, nic_device_id_t, devman_handle_t,
    6363    size_t);
     64extern int nil_device_state_msg(async_sess_t *, nic_device_id_t, sysarg_t);
     65extern int nil_received_msg(async_sess_t *, nic_device_id_t, void *, size_t);
     66extern int nil_addr_changed_msg(async_sess_t *, nic_device_id_t,
     67    const nic_address_t *);
    6468
    6569#endif

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

    rc38e417 reaa0c3f  
    4444#include <ipc/nil.h>
    4545
     46/** Notify the network interface layer about the device state change.
     47 *
     48 * @param[in] sess      Network interface layer session.
     49 * @param[in] device_id Device identifier.
     50 * @param[in] state     New device state.
     51 *
     52 * @return EOK on success.
     53 * @return Other error codes as defined for each specific module
     54 *         device state function.
     55 *
     56 */
     57int nil_device_state_msg(async_sess_t *sess, nic_device_id_t device_id,
     58    sysarg_t state)
     59{
     60        return generic_device_state_msg_remote(sess, NET_NIL_DEVICE_STATE,
     61            device_id, state, 0);
     62}
     63
     64/** Pass the packet queue to the network interface layer.
     65 *
     66 * Process and redistribute the received packet queue to the registered
     67 * upper layers.
     68 *
     69 * @param[in] sess      Network interface layer session.
     70 * @param[in] device_id Source device identifier.
     71 * @param[in] packet    Received packet or the received packet queue.
     72 * @param[in] target    Target service. Ignored parameter.
     73 *
     74 * @return EOK on success.
     75 * @return Other error codes as defined for each specific module
     76 *         received function.
     77 *
     78 */
     79int nil_received_msg(async_sess_t *sess, nic_device_id_t device_id,
     80    void *data, size_t size)
     81{
     82        async_exch_t *exch = async_exchange_begin(sess);
     83
     84        ipc_call_t answer;
     85        aid_t req = async_send_1(exch, NET_NIL_RECEIVED, (sysarg_t) device_id,
     86            &answer);
     87        sysarg_t retval = async_data_write_start(exch, data, size);
     88
     89        async_exchange_end(exch);
     90
     91        if (retval != EOK) {
     92                async_wait_for(req, NULL);
     93                return retval;
     94        }
     95
     96        async_wait_for(req, &retval);
     97        return retval;
     98}
     99
     100/** Notify upper layers that device address has changed
     101 *
     102 */
     103int nil_addr_changed_msg(async_sess_t *sess, nic_device_id_t device_id,
     104    const nic_address_t *address)
     105{
     106        assert(sess);
     107       
     108        async_exch_t *exch = async_exchange_begin(sess);
     109       
     110        aid_t message_id = async_send_1(exch, NET_NIL_ADDR_CHANGED,
     111            (sysarg_t) device_id, NULL);
     112        int rc = async_data_write_start(exch, address, sizeof (nic_address_t));
     113       
     114        async_exchange_end(exch);
     115       
     116        sysarg_t res;
     117    async_wait_for(message_id, &res);
     118       
     119    if (rc != EOK)
     120                return rc;
     121       
     122    return (int) res;
     123}
     124
    46125int nil_device_req(async_sess_t *sess, nic_device_id_t device_id,
    47126    service_id_t sid, size_t mtu)

  • uspace/lib/nic/Makefile

    rc38e417 reaa0c3f  
    3434SOURCES = \
    3535        src/nic_driver.c \
    36         src/nic_ev.c \
    3736        src/nic_addr_db.c \
    3837        src/nic_rx_control.c \

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

    rc38e417 reaa0c3f  
    8080        /** Device's default MAC address (assigned the first time, used in STOP) */
    8181        nic_address_t default_mac;
    82         /** Client callback session */
    83         async_sess_t *client_session;
     82        /** Session to SERVICE_ETHERNET or SERVICE_NILDUMMY */
     83        async_sess_t *nil_session;
    8484        /** Phone to APIC or i8259 */
    8585        async_sess_t *irc_session;

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

    rc38e417 reaa0c3f  
    4949extern int nic_get_address_impl(ddf_fun_t *dev_fun, nic_address_t *address);
    5050extern int nic_send_frame_impl(ddf_fun_t *dev_fun, void *data, size_t size);
    51 extern int nic_callback_create_impl(ddf_fun_t *dev_fun, int device_id);
     51extern int nic_connect_to_nil_impl(ddf_fun_t *dev_fun, services_t nil_service,
     52        int device_id);
    5253extern int nic_get_state_impl(ddf_fun_t *dev_fun, nic_device_state_t *state);
    5354extern int nic_set_state_impl(ddf_fun_t *dev_fun, nic_device_state_t state);

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

    rc38e417 reaa0c3f  
    5353
    5454#include "nic_driver.h"
    55 #include "nic_ev.h"
    5655#include "nic_impl.h"
    5756
    … …  
    107106                if (!iface->send_frame)
    108107                        iface->send_frame = nic_send_frame_impl;
    109                 if (!iface->callback_create)
    110                         iface->callback_create = nic_callback_create_impl;
     108                if (!iface->connect_to_nil)
     109                        iface->connect_to_nil = nic_connect_to_nil_impl;
    111110                if (!iface->get_address)
    112111                        iface->get_address = nic_get_address_impl;
    … …  
    495494       
    496495        /* Notify NIL layer (and uppper) if bound - not in add_device */
    497         if (nic_data->client_session != NULL) {
    498                 int rc = nic_ev_addr_changed(nic_data->client_session,
     496        if (nic_data->nil_session != NULL) {
     497                int rc = nil_addr_changed_msg(nic_data->nil_session,
    499498                    nic_data->device_id, address);
    500499                if (rc != EOK) {
    … …  
    604603                }
    605604                fibril_rwlock_write_unlock(&nic_data->stats_lock);
    606                 nic_ev_received(nic_data->client_session, nic_data->device_id,
     605                nil_received_msg(nic_data->nil_session, nic_data->device_id,
    607606                    frame->data, frame->size);
    608607        } else {
    … …  
    639638        fibril_rwlock_write_unlock(&nic_data->stats_lock);
    640639       
    641         nic_ev_received(nic_data->client_session, nic_data->device_id,
     640        nil_received_msg(nic_data->nil_session, nic_data->device_id,
    642641            data, size);
    643642}
    … …  
    693692        nic_data->device_id = NIC_DEVICE_INVALID_ID;
    694693        nic_data->state = NIC_STATE_STOPPED;
    695         nic_data->client_session = NULL;
     694        nic_data->nil_session = NULL;
    696695        nic_data->irc_session = NULL;
    697696        nic_data->poll_mode = NIC_POLL_IMMEDIATE;
    … …  
    747746 */
    748747static void nic_destroy(nic_t *nic_data) {
    749         if (nic_data->client_session != NULL) {
    750                 async_hangup(nic_data->client_session);
     748        if (nic_data->nil_session != NULL) {
     749                async_hangup(nic_data->nil_session);
    751750        }
    752751

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

    rc38e417 reaa0c3f  
    4040#include <ns.h>
    4141#include "nic_driver.h"
    42 #include "nic_ev.h"
    4342#include "nic_impl.h"
    4443
    … …  
    8685        }
    8786        if (state == NIC_STATE_ACTIVE) {
    88                 if (nic_data->client_session == NULL || nic_data->device_id < 0) {
     87                if (nic_data->nil_session == NULL || nic_data->device_id < 0) {
    8988                        fibril_rwlock_write_unlock(&nic_data->main_lock);
    9089                        return EINVAL;
    … …  
    116115        if (state == NIC_STATE_STOPPED) {
    117116                /* Notify upper layers that we are reseting the MAC */
    118                 int rc = nic_ev_addr_changed(nic_data->client_session,
     117                int rc = nil_addr_changed_msg(nic_data->nil_session,
    119118                        nic_data->device_id, &nic_data->default_mac);
    120119                nic_data->poll_mode = nic_data->default_poll_mode;
    … …  
    149148        nic_data->state = state;
    150149
    151         nic_ev_device_state(nic_data->client_session, nic_data->device_id, state);
     150        nil_device_state_msg(nic_data->nil_session, nic_data->device_id, state);
    152151
    153152        fibril_rwlock_write_unlock(&nic_data->main_lock);
    … …  
    182181
    183182/**
    184  * Default implementation of the connect_client method.
    185  * Creates callback connection to the client.
     183 * Default implementation of the connect_to_nil method.
     184 * Connects the driver to the NIL service.
    186185 *
    187186 * @param       fun
     187 * @param       nil_service     ID of the server implementing the NIL service
    188188 * @param       device_id       ID of the device as used in higher layers
    189189 *
    190  * @return EOK          On success, or negative error code.
    191  */
    192 int nic_callback_create_impl(ddf_fun_t *fun, nic_device_id_t device_id)
    193 {
    194         nic_t *nic = (nic_t *) fun->driver_data;
    195         fibril_rwlock_write_lock(&nic->main_lock);
     190 * @return EOK          If the services were bound
     191 * @return                      Negative error code from service_connect_blocking
     192 */
     193int nic_connect_to_nil_impl(ddf_fun_t *fun, services_t nil_service,
     194    nic_device_id_t device_id)
     195{
     196        nic_t *nic_data = (nic_t *) fun->driver_data;
     197        fibril_rwlock_write_lock(&nic_data->main_lock);
    196198       
    197         nic->device_id = device_id;
     199        nic_data->device_id = device_id;
    198200       
    199         nic->client_session = async_callback_receive(EXCHANGE_SERIALIZE);
    200         if (nic->client_session == NULL) {
    201                 fibril_rwlock_write_unlock(&nic->main_lock);
    202                 return ENOMEM;
     201        nic_data->nil_session = service_connect_blocking(EXCHANGE_SERIALIZE,
     202            nil_service, 0, 0);
     203        if (nic_data->nil_session != NULL) {
     204                fibril_rwlock_write_unlock(&nic_data->main_lock);
     205                return EOK;
    203206        }
    204207       
    205         fibril_rwlock_write_unlock(&nic->main_lock);
    206         return EOK;
     208        fibril_rwlock_write_unlock(&nic_data->main_lock);
     209        return EHANGUP;
    207210}
    208211

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

    rc38e417 reaa0c3f  
    22 * Copyright (c) 2009 Lukas Mejdrech
    33 * Copyright (c) 2011 Radim Vansa
    4  * Copyright (c) 2011 Jiri Svoboda
    54 * All rights reserved.
    65 *
    … …  
    364363                break;
    365364        default:
    366                 printf("%s: Unknown service\n", NAME);
    367365                return ENOENT;
    368366        }

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

    rc38e417 reaa0c3f  
    170170INT_MAP_IMPLEMENT(eth_protos, eth_proto_t);
    171171
    172 static void eth_nic_cb_connection(ipc_callid_t iid, ipc_call_t *icall,
    173     void *arg);
    174 
    175 static int eth_device_state(nic_device_id_t device_id, sysarg_t state)
     172int nil_device_state_msg_local(nic_device_id_t device_id, sysarg_t state)
    176173{
    177174        int index;
    … …  
    347344        }
    348345       
    349         rc = nic_callback_create(device->sess, device_id,
    350             eth_nic_cb_connection, NULL);
    351         if (rc != EOK) {
    352                 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    353                 async_hangup(device->sess);
    354                 free(device);
    355                 return EIO;
    356         }
     346        nic_connect_to_nil(device->sess, SERVICE_ETHERNET, device_id);
    357347       
    358348        /* Get hardware address */
    … …  
    832822       
    833823        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    834         if (rc != EOK) {
    835                 printf("%s: data_write_accept() failed\n", NAME);
     824        if (rc != EOK)
    836825                return rc;
    837         }
    838826       
    839827        packet_t *packet = packet_get_1_remote(eth_globals.net_sess, size);
    … …  
    955943               
    956944                return EOK;
     945        case NET_NIL_DEVICE_STATE:
     946                nil_device_state_msg_local(IPC_GET_DEVICE(*call), IPC_GET_STATE(*call));
     947                async_answer_0(callid, EOK);
     948                return EOK;
     949        case NET_NIL_RECEIVED:
     950                rc = eth_received(IPC_GET_ARG1(*call));
     951                async_answer_0(callid, (sysarg_t) rc);
     952                return rc;
     953        case NET_NIL_ADDR_CHANGED:
     954                rc = eth_addr_changed(IPC_GET_DEVICE(*call));
     955                async_answer_0(callid, (sysarg_t) rc);
     956                return rc;
    957957        }
    958958       
    959959        return ENOTSUP;
    960 }
    961 
    962 static void eth_nic_cb_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    963 {
    964         int rc;
    965        
    966         async_answer_0(iid, EOK);
    967        
    968         while (true) {
    969                 ipc_call_t call;
    970                 ipc_callid_t callid = async_get_call(&call);
    971                
    972                 if (!IPC_GET_IMETHOD(call))
    973                         break;
    974                
    975                 switch (IPC_GET_IMETHOD(call)) {
    976                 case NIC_EV_DEVICE_STATE:
    977                         rc = eth_device_state(IPC_GET_ARG1(call),
    978                             IPC_GET_ARG2(call));
    979                         async_answer_0(callid, (sysarg_t) rc);
    980                         break;
    981                 case NIC_EV_RECEIVED:
    982                         rc = eth_received(IPC_GET_ARG1(call));
    983                         async_answer_0(callid, (sysarg_t) rc);
    984                         break;
    985                 case NIC_EV_ADDR_CHANGED:
    986                         rc = eth_addr_changed(IPC_GET_ARG1(call));
    987                         async_answer_0(callid, (sysarg_t) rc);
    988                         break;
    989                 default:
    990                         async_answer_0(callid, ENOTSUP);
    991                 }
    992         }
    993960}
    994961

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

    rc38e417 reaa0c3f  
    22 * Copyright (c) 2009 Lukas Mejdrech
    33 * Copyright (c) 2011 Radim Vansa
    4  * Copyright (c) 2011 Jiri Svoboda
    54 * All rights reserved.
    65 *
    … …  
    7069DEVICE_MAP_IMPLEMENT(nildummy_devices, nildummy_device_t);
    7170
    72 static void nildummy_nic_cb_conn(ipc_callid_t iid, ipc_call_t *icall,
    73     void *arg);
    74 
    75 static int nildummy_device_state(nic_device_id_t device_id, sysarg_t state)
     71int nil_device_state_msg_local(nic_device_id_t device_id, sysarg_t state)
    7672{
    7773        fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
    … …  
    8278       
    8379        return EOK;
    84 }
    85 
    86 static int nildummy_addr_changed(nic_device_id_t device_id)
    87 {
    88         return ENOTSUP;
    8980}
    9081
    … …  
    182173        }
    183174       
    184         int rc = nic_callback_create(device->sess, device_id,
    185             nildummy_nic_cb_conn, NULL);
    186         if (rc != EOK) {
    187                 async_hangup(device->sess);
    188                
    189                 return ENOENT;
    190         }
     175        nic_connect_to_nil(device->sess, SERVICE_NILDUMMY, device_id);
    191176       
    192177        /* Get hardware address */
    193         rc = nic_get_address(device->sess, &device->addr);
     178        int rc = nic_get_address(device->sess, &device->addr);
    194179        if (rc != EOK) {
    195180                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    … …  
    460445                *answer_count = 1;
    461446                return rc;
     447        case NET_NIL_DEVICE_STATE:
     448                rc = nil_device_state_msg_local(IPC_GET_DEVICE(*call),
     449                    IPC_GET_STATE(*call));
     450                async_answer_0(callid, (sysarg_t) rc);
     451                return rc;
     452       
     453        case NET_NIL_RECEIVED:
     454                rc = nildummy_received(IPC_GET_ARG1(*call));
     455                async_answer_0(callid, (sysarg_t) rc);
     456                return rc;
    462457        }
    463458       
    464459        return ENOTSUP;
    465460}
    466 
    467 static void nildummy_nic_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    468 {
    469         int rc;
    470        
    471         async_answer_0(iid, EOK);
    472        
    473         while (true) {
    474                 ipc_call_t call;
    475                 ipc_callid_t callid = async_get_call(&call);
    476                
    477                 if (!IPC_GET_IMETHOD(call))
    478                         break;
    479                
    480                 switch (IPC_GET_IMETHOD(call)) {
    481                 case NIC_EV_DEVICE_STATE:
    482                         rc = nildummy_device_state(IPC_GET_ARG1(call),
    483                             IPC_GET_ARG2(call));
    484                         async_answer_0(callid, (sysarg_t) rc);
    485                         break;
    486                 case NIC_EV_RECEIVED:
    487                         rc = nildummy_received(IPC_GET_ARG1(call));
    488                         async_answer_0(callid, (sysarg_t) rc);
    489                         break;
    490                 case NIC_EV_ADDR_CHANGED:
    491                         rc = nildummy_addr_changed(IPC_GET_ARG1(call));
    492                         async_answer_0(callid, (sysarg_t) rc);
    493                         break;
    494                 default:
    495                         async_answer_0(callid, ENOTSUP);
    496                 }
    497         }
    498 }
    499 
    500461
    501462int main(int argc, char *argv[])
Note: See TracChangeset for help on using the changeset viewer.