Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/nic/ne2k/ne2k.c

    r9d58539 r80099c19  
    6464#define NE2K(device) ((ne2k_t *) nic_get_specific(DRIVER_DATA(device)))
    6565
    66 static irq_pio_range_t ne2k_ranges_prototype[] = {
    67         {
    68                 .base = 0,
    69                 .size = NE2K_IO_SIZE,
    70         }
    71 };
    72 
    7366/** NE2000 kernel interrupt command sequence.
    7467 *
     
    129122
    130123        if (ne2k->code.cmdcount == 0) {
    131                 irq_pio_range_t *ne2k_ranges;
    132                 irq_cmd_t *ne2k_cmds;
    133 
    134                 ne2k_ranges = malloc(sizeof(ne2k_ranges_prototype));
    135                 if (!ne2k_ranges)
    136                         return ENOMEM;
    137                 memcpy(ne2k_ranges, ne2k_ranges_prototype,
    138                     sizeof(ne2k_ranges_prototype));
    139                 ne2k_ranges[0].base = (uintptr_t) ne2k->base_port;
    140 
    141                 ne2k_cmds = malloc(sizeof(ne2k_cmds_prototype));
    142                 if (!ne2k_cmds) {
    143                         free(ne2k_ranges);
     124                irq_cmd_t *ne2k_cmds = malloc(sizeof(ne2k_cmds_prototype));
     125                if (ne2k_cmds == NULL) {
    144126                        return ENOMEM;
    145127                }
    146                 memcpy(ne2k_cmds, ne2k_cmds_prototype,
    147                     sizeof(ne2k_cmds_prototype));
    148                 ne2k_cmds[0].addr = ne2k->base_port + DP_ISR;
    149                 ne2k_cmds[3].addr = ne2k->base_port + DP_IMR;
     128                memcpy(ne2k_cmds, ne2k_cmds_prototype, sizeof (ne2k_cmds_prototype));
     129                ne2k_cmds[0].addr = ne2k->port + DP_ISR;
     130                ne2k_cmds[3].addr = ne2k->port + DP_IMR;
    150131                ne2k_cmds[4].addr = ne2k_cmds[0].addr;
    151                 ne2k_cmds[5].addr = ne2k->base_port + DP_TSR;
    152 
    153                 ne2k->code.rangecount = sizeof(ne2k_ranges_prototype) /
    154                     sizeof(irq_pio_range_t);
    155                 ne2k->code.ranges = ne2k_ranges;
    156 
    157                 ne2k->code.cmdcount = sizeof(ne2k_cmds_prototype) /
    158                     sizeof(irq_cmd_t);
     132                ne2k_cmds[5].addr = ne2k->port + DP_TSR;
     133
     134                ne2k->code.cmdcount = sizeof(ne2k_cmds_prototype) / sizeof(irq_cmd_t);
    159135                ne2k->code.cmds = ne2k_cmds;
    160136        }
     
    172148                ne2k_t *ne2k = NE2K(dev);
    173149                if (ne2k) {
    174                         free(ne2k->code.ranges);
    175150                        free(ne2k->code.cmds);
    176151                }
     
    286261        /* Note: some frame with previous physical address may slip to NIL here
    287262         * (for a moment the filtering is not exact), but ethernet should be OK with
    288          * that. Some frames may also be lost, but this is not a problem.
     263         * that. Some packet may also be lost, but this is not a problem.
    289264         */
    290265        ne2k_set_physical_address((ne2k_t *) nic_get_specific(nic_data), address);
     
    361336}
    362337
    363 static int ne2k_dev_add(ddf_dev_t *dev)
    364 {
    365         ddf_fun_t *fun;
    366        
     338static int ne2k_add_device(ddf_dev_t *dev)
     339{
    367340        /* Allocate driver data for the device. */
    368341        nic_t *nic_data = nic_create_and_bind(dev);
     
    370343                return ENOMEM;
    371344       
    372         nic_set_send_frame_handler(nic_data, ne2k_send);
     345        nic_set_write_packet_handler(nic_data, ne2k_send);
    373346        nic_set_state_change_handlers(nic_data,
    374347                ne2k_on_activating, NULL, ne2k_on_stopping);
     
    398371        }
    399372       
     373        rc = nic_register_as_ddf_fun(nic_data, &ne2k_dev_ops);
     374        if (rc != EOK) {
     375                ne2k_dev_cleanup(dev);
     376                return rc;
     377        }
     378       
    400379        rc = nic_connect_to_services(nic_data);
    401380        if (rc != EOK) {
     
    404383        }
    405384       
    406         fun = ddf_fun_create(nic_get_ddf_dev(nic_data), fun_exposed, "port0");
    407         if (fun == NULL) {
    408                 ne2k_dev_cleanup(dev);
    409                 return ENOMEM;
    410         }
    411         nic_set_ddf_fun(nic_data, fun);
    412         fun->ops = &ne2k_dev_ops;
    413         fun->driver_data = nic_data;
    414        
    415         rc = ddf_fun_bind(fun);
    416         if (rc != EOK) {
    417                 ddf_fun_destroy(fun);
    418                 ne2k_dev_cleanup(dev);
    419                 return rc;
    420         }
    421        
    422         rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
    423         if (rc != EOK) {
    424                 ddf_fun_unbind(fun);
    425                 ddf_fun_destroy(fun);
    426                 return rc;
    427         }
    428        
    429385        return EOK;
    430386}
     
    435391
    436392static driver_ops_t ne2k_driver_ops = {
    437         .dev_add = ne2k_dev_add
     393        .add_device = ne2k_add_device
    438394};
    439395
Note: See TracChangeset for help on using the changeset viewer.