Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/hw/netif/dp8390/dp8390_module.c

    r66b628a rf87c900  
    4343#include <ipc/ipc.h>
    4444#include <ipc/services.h>
     45
    4546#include <net/modules.h>
    4647#include <packet_client.h>
    … …  
    5051#include <netif_interface.h>
    5152#include <netif_local.h>
     53
    5254#include "dp8390.h"
    5355#include "dp8390_drv.h"
    … …  
    5860#define NAME  "dp8390"
    5961
    60 /** Return the device from the interrupt call.
    61  *
     62/** Returns the device from the interrupt call.
    6263 *  @param[in] call The interrupt call.
    63  *
    64  */
    65 #define IRQ_GET_DEVICE(call)  ((device_id_t) IPC_GET_IMETHOD(call))
    66 
    67 /** Return the ISR from the interrupt call.
    68  *
     64 */
     65#define IRQ_GET_DEVICE(call)                    (device_id_t) IPC_GET_IMETHOD(*call)
     66
     67/** Returns the interrupt status register from the interrupt call.
    6968 *  @param[in] call The interrupt call.
    70  *
    71  */
    72 #define IRQ_GET_ISR(call)  ((int) IPC_GET_ARG2(call))
     69 */
     70#define IPC_GET_ISR(call)                               (int) IPC_GET_ARG2(*call)
    7371
    7472/** DP8390 kernel interrupt command sequence.
    7573 */
    76 static irq_cmd_t dp8390_cmds[] = {
    77         {
    78                 .cmd = CMD_PIO_READ_8,
     74static irq_cmd_t        dp8390_cmds[] = {
     75        {       .cmd = CMD_PIO_READ_8,
    7976                .addr = NULL,
    8077                .dstarg = 2
    8178        },
    8279        {
    83                 .cmd = CMD_BTEST,
    84                 .value = 0x7f,
    85                 .srcarg = 2,
    86                 .dstarg = 3,
    87         },
    88         {
    8980                .cmd = CMD_PREDICATE,
    90                 .value = 2,
    91                 .srcarg = 3
    92         },
    93         {
    94                 .cmd = CMD_PIO_WRITE_A_8,
    95                 .addr = NULL,
    96                 .srcarg = 3
     81                .value = 1,
     82                .srcarg = 2
    9783        },
    9884        {
    … …  
    10389/** DP8390 kernel interrupt code.
    10490 */
    105 static irq_code_t dp8390_code = {
     91static irq_code_t       dp8390_code = {
    10692        sizeof(dp8390_cmds) / sizeof(irq_cmd_t),
    10793        dp8390_cmds
    … …  
    11399 *  @param[in] call The interrupt message.
    114100 */
    115 static void irq_handler(ipc_callid_t iid, ipc_call_t *call)
    116 {
    117         device_id_t device_id = IRQ_GET_DEVICE(*call);
    118         netif_device_t *device;
    119         int nil_phone;
    120         dpeth_t *dep;
    121        
     101static void irq_handler(ipc_callid_t iid, ipc_call_t * call)
     102{
     103        netif_device_t * device;
     104        dpeth_t * dep;
     105        packet_t *received;
     106        device_id_t device_id;
     107        int phone;
     108
     109        device_id = IRQ_GET_DEVICE(call);
    122110        fibril_rwlock_write_lock(&netif_globals.lock);
    123        
    124         if (find_device(device_id, &device) == EOK) {
    125                 nil_phone = device->nil_phone;
    126                 dep = (dpeth_t *) device->specific;
    127         } else
    128                 dep = NULL;
    129        
    130         fibril_rwlock_write_unlock(&netif_globals.lock);
    131        
    132         if ((dep != NULL) && (dep->up)) {
    133                 assert(dep->enabled);
    134                 dp_check_ints(nil_phone, device_id, dep, IRQ_GET_ISR(*call));
    135         }
     111        if(find_device(device_id, &device) != EOK){
     112                fibril_rwlock_write_unlock(&netif_globals.lock);
     113                return;
     114        }
     115        dep = (dpeth_t *) device->specific;
     116        if (dep->de_mode != DEM_ENABLED){
     117                fibril_rwlock_write_unlock(&netif_globals.lock);
     118                return;
     119        }
     120        assert(dep->de_flags &DEF_ENABLED);
     121        dep->de_int_pending = 0;
     122        dp_check_ints(dep, IPC_GET_ISR(call));
     123        if(dep->received_queue){
     124                received = dep->received_queue;
     125                phone = device->nil_phone;
     126                dep->received_queue = NULL;
     127                dep->received_count = 0;
     128                fibril_rwlock_write_unlock(&netif_globals.lock);
     129                nil_received_msg(phone, device_id, received, SERVICE_NONE);
     130        }else{
     131                fibril_rwlock_write_unlock(&netif_globals.lock);
     132        }
     133        ipc_answer_0(iid, EOK);
    136134}
    137135
    … …  
    141139 *  @returns The new state.
    142140 */
    143 static int change_state(netif_device_t *device, device_state_t state)
     141static int change_state(netif_device_t * device, device_state_t state)
    144142{
    145143        if (device->state != state) {
    … …  
    155153}
    156154
    157 int netif_specific_message(ipc_callid_t callid, ipc_call_t *call,
    158     ipc_call_t *answer, int *answer_count)
    159 {
     155int netif_specific_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
    160156        return ENOTSUP;
    161157}
    … …  
    166162        eth_stat_t * de_stat;
    167163        int rc;
    168        
    169         if (!stats)
     164
     165        if(! stats){
    170166                return EBADMEM;
    171        
     167        }
    172168        rc = find_device(device_id, &device);
    173169        if (rc != EOK)
    174170                return rc;
    175        
    176171        de_stat = &((dpeth_t *) device->specific)->de_stat;
    177        
    178172        null_device_stats(stats);
    179173        stats->receive_errors = de_stat->ets_recvErr;
    … …  
    189183        stats->send_heartbeat_errors = de_stat->ets_CDheartbeat;
    190184        stats->send_window_errors = de_stat->ets_OWC;
    191        
    192         return EOK;
    193 }
    194 
    195 int netif_get_addr_message(device_id_t device_id, measured_string_t *address)
    196 {
    197         netif_device_t *device;
    198         int rc;
    199        
    200         if (!address)
     185        return EOK;
     186}
     187
     188int netif_get_addr_message(device_id_t device_id, measured_string_t *address){
     189        netif_device_t * device;
     190        int rc;
     191
     192        if(! address){
    201193                return EBADMEM;
    202        
     194        }
    203195        rc = find_device(device_id, &device);
    204196        if (rc != EOK)
    205197                return rc;
    206        
    207198        address->value = (char *) (&((dpeth_t *) device->specific)->de_address);
    208199        address->length = sizeof(ether_addr_t);
    … …  
    210201}
    211202
    212 int netif_probe_message(device_id_t device_id, int irq, uintptr_t io)
    213 {
    214         netif_device_t *device;
    215         dpeth_t *dep;
    216         int rc;
    217        
     203
     204
     205int netif_probe_message(device_id_t device_id, int irq, uintptr_t io){
     206        netif_device_t * device;
     207        dpeth_t * dep;
     208        int rc;
     209
    218210        device = (netif_device_t *) malloc(sizeof(netif_device_t));
    219         if (!device)
     211        if(! device){
    220212                return ENOMEM;
    221        
     213        }
    222214        dep = (dpeth_t *) malloc(sizeof(dpeth_t));
    223         if (!dep) {
     215        if(! dep){
    224216                free(device);
    225217                return ENOMEM;
    226218        }
    227        
    228219        bzero(device, sizeof(netif_device_t));
    229220        bzero(dep, sizeof(dpeth_t));
    … …  
    233224        device->state = NETIF_STOPPED;
    234225        dep->de_irq = irq;
    235         dep->up = false;
    236        
     226        dep->de_mode = DEM_DISABLED;
    237227        //TODO address?
    238228        rc = pio_enable((void *) io, DP8390_IO_SIZE, (void **) &dep->de_base_port);
    … …  
    241231                free(device);
    242232                return rc;
    243         }
    244        
     233        }       
    245234        rc = do_probe(dep);
    246235        if (rc != EOK) {
    … …  
    249238                return rc;
    250239        }
    251        
    252240        rc = netif_device_map_add(&netif_globals.device_map, device->device_id, device);
    253         if (rc != EOK) {
     241        if (rc != EOK){
    254242                free(dep);
    255243                free(device);
    256244                return rc;
    257245        }
    258        
    259         return EOK;
    260 }
    261 
    262 int netif_send_message(device_id_t device_id, packet_t *packet,
    263     services_t sender)
    264 {
    265         netif_device_t *device;
    266         dpeth_t *dep;
     246        return EOK;
     247}
     248
     249int netif_send_message(device_id_t device_id, packet_t *packet, services_t sender){
     250        netif_device_t * device;
     251        dpeth_t * dep;
    267252        packet_t *next;
    268253        int rc;
    269        
     254
    270255        rc = find_device(device_id, &device);
    271256        if (rc != EOK)
    272257                return rc;
    273        
    274         if (device->state != NETIF_ACTIVE){
     258        if(device->state != NETIF_ACTIVE){
    275259                netif_pq_release(packet_get_id(packet));
    276260                return EFORWARD;
    277261        }
    278        
    279262        dep = (dpeth_t *) device->specific;
    280        
    281         /* Process packet queue */
    282         do {
     263        // process packet queue
     264        do{
    283265                next = pq_detach(packet);
    284                
    285                 if (do_pwrite(dep, packet, false) != EBUSY)
     266                if(do_pwrite(dep, packet, FALSE) != EBUSY){
    286267                        netif_pq_release(packet_get_id(packet));
    287                
     268                }
    288269                packet = next;
    289         } while (packet);
    290        
    291         return EOK;
    292 }
    293 
    294 int netif_start_message(netif_device_t * device)
    295 {
    296         dpeth_t *dep;
    297         int rc;
    298        
    299         if (device->state != NETIF_ACTIVE) {
     270        }while(packet);
     271        return EOK;
     272}
     273
     274int netif_start_message(netif_device_t * device){
     275        dpeth_t * dep;
     276        int rc;
     277
     278        if(device->state != NETIF_ACTIVE){
    300279                dep = (dpeth_t *) device->specific;
    301280                dp8390_cmds[0].addr = (void *) (uintptr_t) (dep->de_dp8390_port + DP_ISR);
    302                 dp8390_cmds[3].addr = dp8390_cmds[0].addr;
    303                
     281                dp8390_cmds[2].addr = dp8390_cmds[0].addr;
    304282                rc = ipc_register_irq(dep->de_irq, device->device_id, device->device_id, &dp8390_code);
    305283                if (rc != EOK)
    306284                        return rc;
    307                
    308                 rc = do_init(dep);
     285                rc = do_init(dep, DL_BROAD_REQ);
    309286                if (rc != EOK) {
    310287                        ipc_unregister_irq(dep->de_irq, device->device_id);
    311288                        return rc;
    312289                }
    313                
    314290                return change_state(device, NETIF_ACTIVE);
    315291        }
    316        
    317         return EOK;
    318 }
    319 
    320 int netif_stop_message(netif_device_t * device)
    321 {
    322         dpeth_t *dep;
    323        
    324         if (device->state != NETIF_STOPPED) {
     292        return EOK;
     293}
     294
     295int netif_stop_message(netif_device_t * device){
     296        dpeth_t * dep;
     297
     298        if(device->state != NETIF_STOPPED){
    325299                dep = (dpeth_t *) device->specific;
    326300                do_stop(dep);
    … …  
    328302                return change_state(device, NETIF_STOPPED);
    329303        }
    330        
    331         return EOK;
    332 }
    333 
    334 int netif_initialize(void)
    335 {
     304        return EOK;
     305}
     306
     307int netif_initialize(void){
    336308        sysarg_t phonehash;
     309
    337310        async_set_interrupt_received(irq_handler);
     311
    338312        return ipc_connect_to_me(PHONE_NS, SERVICE_DP8390, 0, 0, &phonehash);
    339313}
    … …  
    345319 *
    346320 */
    347 static void netif_client_connection(ipc_callid_t iid, ipc_call_t *icall)
     321static void netif_client_connection(ipc_callid_t iid, ipc_call_t * icall)
    348322{
    349323        /*
    … …  
    353327        ipc_answer_0(iid, EOK);
    354328       
    355         while (true) {
     329        while(true) {
    356330                ipc_call_t answer;
    357331                int answer_count;
    … …  
    377351}
    378352
    379 /** Start the module.
     353/** Starts the module.
    380354 *
    381355 *  @param argc The count of the command line arguments. Ignored parameter.
    … …  
    388362int main(int argc, char *argv[])
    389363{
     364        int rc;
     365       
    390366        /* Start the module */
    391         return netif_module_start(netif_client_connection);
     367        rc = netif_module_start(netif_client_connection);
     368        return rc;
    392369}
    393370
Note: See TracChangeset for help on using the changeset viewer.