Ignore:
Timestamp:
2011-01-06T15:41:05Z (13 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade
Children:
6fc0edd
Parents:
74864ac
Message:

improve dp_check_ints

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/hw/netif/dp8390/dp8390_module.c

    r74864ac r0777f4c5  
    6161 *  @param[in] call The interrupt call.
    6262 */
    63 #define IRQ_GET_DEVICE(call)                    (device_id_t) IPC_GET_IMETHOD(*call)
    64 
    65 /** Returns the interrupt status register from the interrupt call.
    66  *  @param[in] call The interrupt call.
    67  */
    68 #define IPC_GET_ISR(call)                               (int) IPC_GET_ARG2(*call)
     63#define IRQ_GET_DEVICE(call)  (device_id_t) IPC_GET_IMETHOD(*call)
    6964
    7065/** DP8390 kernel interrupt command sequence.
    7166 */
    72 static irq_cmd_t        dp8390_cmds[] = {
    73         {       .cmd = CMD_PIO_READ_8,
     67static irq_cmd_t dp8390_cmds[] = {
     68        {
     69                .cmd = CMD_PIO_READ_8,
    7470                .addr = NULL,
    7571                .dstarg = 2
     
    8783/** DP8390 kernel interrupt code.
    8884 */
    89 static irq_code_t       dp8390_code = {
     85static irq_code_t dp8390_code = {
    9086        sizeof(dp8390_cmds) / sizeof(irq_cmd_t),
    9187        dp8390_cmds
     
    9793 *  @param[in] call The interrupt message.
    9894 */
    99 static void irq_handler(ipc_callid_t iid, ipc_call_t * call)
    100 {
    101         netif_device_t * device;
    102         dpeth_t * dep;
     95static void irq_handler(ipc_callid_t iid, ipc_call_t *call)
     96{
     97        netif_device_t *device;
     98        dpeth_t *dep;
    10399        packet_t *received;
    104100        device_id_t device_id;
    105101        int phone;
    106 
     102       
    107103        device_id = IRQ_GET_DEVICE(call);
    108104        fibril_rwlock_write_lock(&netif_globals.lock);
    109         if(find_device(device_id, &device) != EOK){
     105       
     106        if (find_device(device_id, &device) != EOK) {
    110107                fibril_rwlock_write_unlock(&netif_globals.lock);
    111108                return;
    112109        }
     110       
    113111        dep = (dpeth_t *) device->specific;
    114         if (dep->de_mode != DEM_ENABLED){
     112        if (dep->de_mode != DEM_ENABLED) {
    115113                fibril_rwlock_write_unlock(&netif_globals.lock);
    116114                return;
    117115        }
    118         assert(dep->de_flags &DEF_ENABLED);
     116       
     117        assert(dep->de_flags & DEF_ENABLED);
     118       
    119119        dep->de_int_pending = 0;
    120         dp_check_ints(dep, IPC_GET_ISR(call));
    121         if(dep->received_queue){
     120        dp_check_ints(dep);
     121       
     122        if (dep->received_queue) {
    122123                received = dep->received_queue;
    123124                phone = device->nil_phone;
     
    126127                fibril_rwlock_write_unlock(&netif_globals.lock);
    127128                nil_received_msg(phone, device_id, received, SERVICE_NONE);
    128         }else{
     129        } else
    129130                fibril_rwlock_write_unlock(&netif_globals.lock);
    130         }
    131131}
    132132
     
    136136 *  @returns The new state.
    137137 */
    138 static int change_state(netif_device_t * device, device_state_t state)
     138static int change_state(netif_device_t *device, device_state_t state)
    139139{
    140140        if (device->state != state) {
     
    150150}
    151151
    152 int netif_specific_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
     152int netif_specific_message(ipc_callid_t callid, ipc_call_t *call,
     153    ipc_call_t *answer, int *answer_count)
     154{
    153155        return ENOTSUP;
    154156}
     
    159161        eth_stat_t * de_stat;
    160162        int rc;
    161 
    162         if(! stats){
     163       
     164        if (!stats)
    163165                return EBADMEM;
    164         }
     166       
    165167        rc = find_device(device_id, &device);
    166168        if (rc != EOK)
    167169                return rc;
     170       
    168171        de_stat = &((dpeth_t *) device->specific)->de_stat;
     172       
    169173        null_device_stats(stats);
    170174        stats->receive_errors = de_stat->ets_recvErr;
     
    180184        stats->send_heartbeat_errors = de_stat->ets_CDheartbeat;
    181185        stats->send_window_errors = de_stat->ets_OWC;
    182         return EOK;
    183 }
    184 
    185 int netif_get_addr_message(device_id_t device_id, measured_string_t *address){
    186         netif_device_t * device;
    187         int rc;
    188 
    189         if(! address){
     186       
     187        return EOK;
     188}
     189
     190int netif_get_addr_message(device_id_t device_id, measured_string_t *address)
     191{
     192        netif_device_t *device;
     193        int rc;
     194       
     195        if (!address)
    190196                return EBADMEM;
    191         }
     197       
    192198        rc = find_device(device_id, &device);
    193199        if (rc != EOK)
    194200                return rc;
     201       
    195202        address->value = (char *) (&((dpeth_t *) device->specific)->de_address);
    196203        address->length = sizeof(ether_addr_t);
     
    198205}
    199206
    200 
    201 
    202 int netif_probe_message(device_id_t device_id, int irq, uintptr_t io){
    203         netif_device_t * device;
    204         dpeth_t * dep;
    205         int rc;
    206 
     207int netif_probe_message(device_id_t device_id, int irq, uintptr_t io)
     208{
     209        netif_device_t *device;
     210        dpeth_t *dep;
     211        int rc;
     212       
    207213        device = (netif_device_t *) malloc(sizeof(netif_device_t));
    208         if(! device){
     214        if (!device)
    209215                return ENOMEM;
    210         }
     216       
    211217        dep = (dpeth_t *) malloc(sizeof(dpeth_t));
    212         if(! dep){
     218        if (!dep) {
    213219                free(device);
    214220                return ENOMEM;
    215221        }
     222       
    216223        bzero(device, sizeof(netif_device_t));
    217224        bzero(dep, sizeof(dpeth_t));
     
    222229        dep->de_irq = irq;
    223230        dep->de_mode = DEM_DISABLED;
     231       
    224232        //TODO address?
    225233        rc = pio_enable((void *) io, DP8390_IO_SIZE, (void **) &dep->de_base_port);
     
    228236                free(device);
    229237                return rc;
    230         }       
     238        }
     239       
    231240        rc = do_probe(dep);
    232241        if (rc != EOK) {
     
    235244                return rc;
    236245        }
     246       
    237247        rc = netif_device_map_add(&netif_globals.device_map, device->device_id, device);
    238         if (rc != EOK){
     248        if (rc != EOK) {
    239249                free(dep);
    240250                free(device);
    241251                return rc;
    242252        }
    243         return EOK;
    244 }
    245 
    246 int netif_send_message(device_id_t device_id, packet_t *packet, services_t sender){
    247         netif_device_t * device;
    248         dpeth_t * dep;
     253       
     254        return EOK;
     255}
     256
     257int netif_send_message(device_id_t device_id, packet_t *packet,
     258    services_t sender)
     259{
     260        netif_device_t *device;
     261        dpeth_t *dep;
    249262        packet_t *next;
    250263        int rc;
    251 
     264       
    252265        rc = find_device(device_id, &device);
    253266        if (rc != EOK)
    254267                return rc;
    255         if(device->state != NETIF_ACTIVE){
     268       
     269        if (device->state != NETIF_ACTIVE){
    256270                netif_pq_release(packet_get_id(packet));
    257271                return EFORWARD;
    258272        }
     273       
    259274        dep = (dpeth_t *) device->specific;
    260         // process packet queue
    261         do{
     275       
     276        /* Process packet queue */
     277        do {
    262278                next = pq_detach(packet);
    263                 if(do_pwrite(dep, packet, false) != EBUSY){
    264                         netif_pq_release(packet_get_id(packet));
    265                 }
     279               
     280                if (do_pwrite(dep, packet, false) != EBUSY)
     281                        netif_pq_release(packet_get_id(packet));\
     282               
    266283                packet = next;
    267         }while(packet);
    268         return EOK;
    269 }
    270 
    271 int netif_start_message(netif_device_t * device){
    272         dpeth_t * dep;
    273         int rc;
    274 
    275         if(device->state != NETIF_ACTIVE){
     284        } while(packet);
     285       
     286        return EOK;
     287}
     288
     289int netif_start_message(netif_device_t * device)
     290{
     291        dpeth_t *dep;
     292        int rc;
     293       
     294        if (device->state != NETIF_ACTIVE) {
    276295                dep = (dpeth_t *) device->specific;
    277296                dp8390_cmds[0].addr = (void *) (uintptr_t) (dep->de_dp8390_port + DP_ISR);
    278297                dp8390_cmds[2].addr = dp8390_cmds[0].addr;
     298               
    279299                rc = ipc_register_irq(dep->de_irq, device->device_id, device->device_id, &dp8390_code);
    280300                if (rc != EOK)
    281301                        return rc;
     302               
    282303                rc = do_init(dep, DL_BROAD_REQ);
    283304                if (rc != EOK) {
     
    285306                        return rc;
    286307                }
     308               
    287309                return change_state(device, NETIF_ACTIVE);
    288310        }
    289         return EOK;
    290 }
    291 
    292 int netif_stop_message(netif_device_t * device){
    293         dpeth_t * dep;
    294 
    295         if(device->state != NETIF_STOPPED){
     311       
     312        return EOK;
     313}
     314
     315int netif_stop_message(netif_device_t * device)
     316{
     317        dpeth_t *dep;
     318       
     319        if (device->state != NETIF_STOPPED) {
    296320                dep = (dpeth_t *) device->specific;
    297321                do_stop(dep);
     
    299323                return change_state(device, NETIF_STOPPED);
    300324        }
    301         return EOK;
    302 }
    303 
    304 int netif_initialize(void){
     325       
     326        return EOK;
     327}
     328
     329int netif_initialize(void)
     330{
    305331        sysarg_t phonehash;
    306 
    307332        async_set_interrupt_received(irq_handler);
    308 
    309333        return ipc_connect_to_me(PHONE_NS, SERVICE_DP8390, 0, 0, &phonehash);
    310334}
     
    316340 *
    317341 */
    318 static void netif_client_connection(ipc_callid_t iid, ipc_call_t * icall)
     342static void netif_client_connection(ipc_callid_t iid, ipc_call_t *icall)
    319343{
    320344        /*
     
    324348        ipc_answer_0(iid, EOK);
    325349       
    326         while(true) {
     350        while (true) {
    327351                ipc_call_t answer;
    328352                int answer_count;
     
    348372}
    349373
    350 /** Starts the module.
     374/** Start the module.
    351375 *
    352376 *  @param argc The count of the command line arguments. Ignored parameter.
     
    359383int main(int argc, char *argv[])
    360384{
    361         int rc;
    362        
    363385        /* Start the module */
    364         rc = netif_module_start(netif_client_connection);
    365         return rc;
     386        return netif_module_start(netif_client_connection);
    366387}
    367388
Note: See TracChangeset for help on using the changeset viewer.