Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/net/nil/eth/eth.c

    r8d7ec69d r4ee7364  
    4848#include <ipc/net.h>
    4949#include <ipc/services.h>
    50 #include <loc.h>
    5150#include <net/modules.h>
    5251#include <net_checksum.h>
     
    170169INT_MAP_IMPLEMENT(eth_protos, eth_proto_t);
    171170
    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)
     171int nil_device_state_msg_local(nic_device_id_t device_id, sysarg_t state)
    176172{
    177173        int index;
     
    230226 *
    231227 * @param[in] device_id New device identifier.
    232  * @param[in] sid       NIC service ID.
     228 * @param[in] handle    Device driver handle.
    233229 * @param[in] mtu       Device maximum transmission unit.
    234230 *
     
    238234 *
    239235 */
    240 static int eth_device_message(nic_device_id_t device_id, service_id_t sid,
     236static int eth_device_message(nic_device_id_t device_id, devman_handle_t handle,
    241237    size_t mtu)
    242238{
     
    263259        device = eth_devices_find(&eth_globals.devices, device_id);
    264260        if (device) {
    265                 if (device->sid != sid) {
     261                if (device->handle != handle) {
    266262                        printf("Device %d already exists\n", device->device_id);
    267263                        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     
    302298
    303299        device->device_id = device_id;
    304         device->sid = sid;
     300        device->handle = handle;
    305301        device->flags = 0;
    306302        if ((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags)))
     
    339335       
    340336        /* Bind the device driver */
    341         device->sess = loc_service_connect(EXCHANGE_SERIALIZE, sid,
     337        device->sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
    342338            IPC_FLAG_BLOCKING);
    343339        if (device->sess == NULL) {
     
    347343        }
    348344       
    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         }
     345        nic_connect_to_nil(device->sess, SERVICE_ETHERNET, device_id);
    357346       
    358347        /* Get hardware address */
     
    373362        }
    374363       
    375         printf("%s: Device registered (id: %d, sid: %zu: mtu: %zu, "
     364        printf("%s: Device registered (id: %d, handle: %zu: mtu: %zu, "
    376365            "mac: " PRIMAC ", flags: 0x%x)\n", NAME,
    377             device->device_id, device->sid, device->mtu,
     366            device->device_id, device->handle, device->mtu,
    378367            ARGSMAC(device->addr.address), device->flags);
    379368
     
    813802                        next = tmp;
    814803                } else {
    815                         nic_send_frame(device->sess, packet_get_data(next),
    816                             packet_get_data_length(next));
    817804                        next = pq_next(next);
    818805                }
    819806        } while (next);
    820807       
    821         pq_release_remote(eth_globals.net_sess, packet_get_id(packet));
     808        /* Send packet queue */
     809        if (packet)
     810                nic_send_message(device->sess, packet_get_id(packet));
    822811       
    823812        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    824813        return EOK;
    825 }
    826 
    827 static int eth_received(nic_device_id_t device_id)
    828 {
    829         void *data;
    830         size_t size;
    831         int rc;
    832        
    833         rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    834         if (rc != EOK) {
    835                 printf("%s: data_write_accept() failed\n", NAME);
    836                 return rc;
    837         }
    838        
    839         packet_t *packet = packet_get_1_remote(eth_globals.net_sess, size);
    840         if (packet == NULL)
    841                 return ENOMEM;
    842        
    843         void *pdata = packet_suffix(packet, size);
    844         memcpy(pdata, data, size);
    845         free(data);
    846        
    847         return nil_received_msg_local(device_id, packet);
    848814}
    849815
     
    955921               
    956922                return EOK;
     923        case NET_NIL_DEVICE_STATE:
     924                nil_device_state_msg_local(IPC_GET_DEVICE(*call), IPC_GET_STATE(*call));
     925                async_answer_0(callid, EOK);
     926                return EOK;
     927        case NET_NIL_RECEIVED:
     928                rc = packet_translate_remote(eth_globals.net_sess, &packet,
     929                    IPC_GET_ARG2(*call));
     930                if (rc == EOK)
     931                        rc = nil_received_msg_local(IPC_GET_ARG1(*call), packet);
     932               
     933                async_answer_0(callid, (sysarg_t) rc);
     934                return rc;
     935        case NET_NIL_ADDR_CHANGED:
     936                rc = eth_addr_changed(IPC_GET_DEVICE(*call));
     937                async_answer_0(callid, (sysarg_t) rc);
     938                return rc;
    957939        }
    958940       
    959941        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         }
    993942}
    994943
Note: See TracChangeset for help on using the changeset viewer.