Subversion Repositories HelenOS

Rev

Rev 3912 | Rev 4192 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3666 mejdrech 1
/*
3912 mejdrech 2
 * Copyright (c) 2009 Lukas Mejdrech
3666 mejdrech 3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
3912 mejdrech 29
/** @addtogroup netif
30
 *  @{
3666 mejdrech 31
 */
32
 
33
/** @file
34
 */
35
 
36
#include <async.h>
37
#include <stdio.h>
3846 mejdrech 38
 
3666 mejdrech 39
#include <ipc/ipc.h>
40
#include <ipc/services.h>
41
//#include <sys/mman.h>
42
 
43
#include "../err.h"
44
#include "../messages.h"
45
#include "../modules.h"
46
 
3886 mejdrech 47
#include "../structures/packet/packet.h"
3901 mejdrech 48
#include "../structures/packet/packet_client.h"
3886 mejdrech 49
 
3846 mejdrech 50
#include "device.h"
3666 mejdrech 51
#include "netif.h"
52
 
3846 mejdrech 53
#define IPC_GET_DEVICE( call )      ( device_id_t ) IPC_GET_ARG1( * call )
3901 mejdrech 54
#define IPC_GET_PACKET( call )      ( packet_id_t ) IPC_GET_ARG2( * call )
3846 mejdrech 55
#define IPC_GET_IRQ( call )     ( int ) IPC_GET_ARG2( * call )
56
#define IPC_GET_IO( call )      ( int ) IPC_GET_ARG3( * call )
57
#define IPC_GET_PHONE( call )       ( int ) IPC_GET_ARG5( * call )
58
 
3666 mejdrech 59
extern netif_globals_t netif_globals;
60
 
3846 mejdrech 61
extern int  initialize( void );
62
extern int  probe_auto_message( void );
63
extern int  probe_message( device_id_t device_id, int irq, int io );
64
extern int  send_message( device_id_t device_id, packet_t packet );
65
extern int  start_message( device_id_t device_id );
66
extern int  stop_message( device_id_t device_id );
3666 mejdrech 67
 
3846 mejdrech 68
DEVICE_MAP_IMPLEMENT( device_map, device_t )
3666 mejdrech 69
 
3846 mejdrech 70
int module_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count );
71
int netif_start_module( async_client_conn_t client_connection );
72
int register_message( device_id_t device_id, int phone );
73
int get_device_stats( device_id_t device_id, device_stats_ref * stats );
3666 mejdrech 74
 
3846 mejdrech 75
int find_device( device_id_t device_id, device_ref * device ){
76
    * device = device_map_find( & netif_globals.device_map, device_id );
3666 mejdrech 77
    if( ! * device ) return ENOENT;
3685 mejdrech 78
    if(( ** device ).state == NETIF_NULL ) return EPERM;
3666 mejdrech 79
    return EOK;
80
}
81
 
3846 mejdrech 82
int get_device_stats( device_id_t device_id, device_stats_ref * stats ){
83
    ERROR_DECLARE;
84
 
85
    device_ref  device;
86
 
87
    if( ! stats ) return EINVAL;
88
    ERROR_PROPAGATE( find_device( device_id, & device ));
89
    * stats = & device->stats;
90
    return EOK;
91
}
92
 
93
void null_device_stats( device_stats_ref stats ){
94
    memset( stats, 0, sizeof( device_stats_t ));
95
/*  stats->rx_packets = 0;
3666 mejdrech 96
    stats->tx_packets = 0;
97
    stats->rx_bytes = 0;
98
    stats->tx_bytes = 0;
99
    stats->rx_errors = 0;
100
    stats->tx_errors = 0;
101
    stats->rx_dropped = 0;
102
    stats->tx_dropped = 0;
103
    stats->multicast = 0;
104
    stats->collisions = 0;
105
    stats->rx_length_errors = 0;
106
    stats->rx_over_errors = 0;
107
    stats->rx_crc_errors = 0;
108
    stats->rx_frame_errors = 0;
109
    stats->rx_fifo_errors = 0;
110
    stats->rx_missed_errors = 0;
111
    stats->tx_aborted_errors = 0;
112
    stats->tx_carrier_errors = 0;
113
    stats->tx_fifo_errors = 0;
114
    stats->tx_heartbeat_errors = 0;
115
    stats->tx_window_errors = 0;
116
    stats->rx_compressed = 0;
117
    stats->tx_compressed = 0;
3846 mejdrech 118
*/
3666 mejdrech 119
}
120
 
3846 mejdrech 121
int register_message( device_id_t device_id, int phone ){
3666 mejdrech 122
    ERROR_DECLARE;
123
 
3846 mejdrech 124
    device_ref  device;
125
 
126
    ERROR_PROPAGATE( find_device( device_id, & device ));
127
    if( device->nil_phone ) return ELIMIT;
128
    device->nil_phone = phone;
129
    return EOK;
130
}
131
 
132
int netif_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
133
    ERROR_DECLARE;
134
 
3666 mejdrech 135
    size_t          length;
3846 mejdrech 136
    device_stats_ref    stats;
137
    packet_t        packet;
3666 mejdrech 138
 
139
//  printf( "\nNETIF message %d", method );
3846 mejdrech 140
    * answer_count = 0;
141
    switch( IPC_GET_METHOD( * call )){
3666 mejdrech 142
        case IPC_M_PHONE_HUNGUP:
143
            return EOK;
144
        case NET_NETIF_PROBE_AUTO:
3846 mejdrech 145
            return probe_auto_message();
3666 mejdrech 146
        case NET_NETIF_PROBE:
3846 mejdrech 147
            return probe_message( IPC_GET_DEVICE( call ), IPC_GET_IRQ( call ), IPC_GET_IO( call ));
148
        case IPC_M_CONNECT_TO_ME:
149
            return register_message( IPC_GET_DEVICE( call ), IPC_GET_PHONE( call ));
3666 mejdrech 150
        case NET_NETIF_SEND:
3901 mejdrech 151
            ERROR_PROPAGATE( packet_translate( netif_globals.networking_phone, & packet, IPC_GET_PACKET( call )));
3846 mejdrech 152
            return send_message( IPC_GET_DEVICE( call ), packet );
3666 mejdrech 153
        case NET_NETIF_START:
3846 mejdrech 154
            return start_message( IPC_GET_DEVICE( call ));
3666 mejdrech 155
        case NET_NETIF_STATS:
156
            ERROR_PROPAGATE( ipc_data_read_receive( & callid, & length ));
3846 mejdrech 157
            if( length < sizeof( device_stats_t )) return EOVERFLOW;
158
            ERROR_PROPAGATE( get_device_stats( IPC_GET_DEVICE( call ), & stats ));
159
            return ipc_data_read_finalize( callid, stats, sizeof( device_stats_t ));
3666 mejdrech 160
        case NET_NETIF_STOP:
3846 mejdrech 161
            return stop_message( IPC_GET_DEVICE( call ));
3666 mejdrech 162
    }
163
    return ENOTSUP;
164
}
165
 
3846 mejdrech 166
int netif_start_module( async_client_conn_t client_connection ){
167
    ERROR_DECLARE;
3666 mejdrech 168
 
3846 mejdrech 169
    async_set_client_connection( client_connection );
170
    netif_globals.networking_phone = connect_to_service( SERVICE_NETWORKING );
171
    device_map_initialize( & netif_globals.device_map );
3912 mejdrech 172
    ERROR_PROPAGATE( pm_init());
3914 mejdrech 173
    if( ERROR_OCCURRED( initialize())){
174
        pm_destroy();
175
        return ERROR_CODE;
176
    }
3912 mejdrech 177
 
3846 mejdrech 178
    async_manager();
179
 
3912 mejdrech 180
    pm_destroy();
3846 mejdrech 181
    return EOK;
3666 mejdrech 182
}
183
 
184
/** @}
185
 */