uspace/drv/nic/ne2k/ne2k.c

   1 /*
   2  * Copyright (c) 2011 Martin Decky
   3  * Copyright (c) 2011 Radim Vansa
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright
  11  *   notice, this list of conditions and the following disclaimer.
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice, this list of conditions and the following disclaimer in the
  14  *   documentation and/or other materials provided with the distribution.
  15  * - The name of the author may not be used to endorse or promote products
  16  *   derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 /**
  31  * @addtogroup drv_ne2k
  32  * @{
  33  */
  34 /**
  35  * @file
  36  * @brief Bridge between NICF, DDF and business logic for the NIC
  37  */
  38
  39 #include <stdio.h>
  40 #include <errno.h>
  41 #include <device/hw_res.h>
  42 #include <stdlib.h>
  43 #include <str_error.h>
  44 #include <async.h>
  45 #include "dp8390.h"
  46
  47 #define NAME  "ne2k"
  48
  49 /** Return the ISR from the interrupt call.
  50  *
  51  * @param[in] call The interrupt call.
  52  *
  53  */
  54 #define IRQ_GET_ISR(call)  ((int) ipc_get_arg2(&call))
  55
  56 /** Return the TSR from the interrupt call.
  57  *
  58  * @param[in] call The interrupt call.
  59  *
  60  */
  61 #define IRQ_GET_TSR(call)  ((int) ipc_get_arg3(&call))
  62
  63 #define DRIVER_DATA(dev) ((nic_t *) ddf_dev_data_get(dev))
  64 #define NE2K(device) ((ne2k_t *) nic_get_specific(DRIVER_DATA(device)))
  65
  66 static irq_pio_range_t ne2k_ranges_prototype[] = {
  67         {
  68                 .base = 0,
  69                 .size = NE2K_IO_SIZE,
  70         }
  71 };
  72
  73 /** NE2000 kernel interrupt command sequence.
  74  *
  75  */
  76 static irq_cmd_t ne2k_cmds_prototype[] = {
  77         {
  78                 /* Read Interrupt Status Register */
  79                 .cmd = CMD_PIO_READ_8,
  80                 .addr = NULL,
  81                 .dstarg = 2
  82         },
  83         {
  84                 /* Mask supported interrupt causes */
  85                 .cmd = CMD_AND,
  86                 .value = (ISR_PRX | ISR_PTX | ISR_RXE | ISR_TXE | ISR_OVW |
  87                     ISR_CNT | ISR_RDC),
  88                 .srcarg = 2,
  89                 .dstarg = 3,
  90         },
  91         {
  92                 /* Predicate for accepting the interrupt */
  93                 .cmd = CMD_PREDICATE,
  94                 .value = 4,
  95                 .srcarg = 3
  96         },
  97         {
  98                 /*
  99                  * Mask future interrupts via
 100                  * Interrupt Mask Register
 101                  */
 102                 .cmd = CMD_PIO_WRITE_8,
 103                 .addr = NULL,
 104                 .value = 0
 105         },
 106         {
 107                 /* Acknowledge the current interrupt */
 108                 .cmd = CMD_PIO_WRITE_A_8,
 109                 .addr = NULL,
 110                 .srcarg = 3
 111         },
 112         {
 113                 /* Read Transmit Status Register */
 114                 .cmd = CMD_PIO_READ_8,
 115                 .addr = NULL,
 116                 .dstarg = 3
 117         },
 118         {
 119                 .cmd = CMD_ACCEPT
 120         }
 121 };
 122
 123 static void ne2k_interrupt_handler(ipc_call_t *, void *);
 124
 125 static errno_t ne2k_register_interrupt(nic_t *nic_data,
 126     cap_irq_handle_t *handle)
 127 {
 128         ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
 129
 130         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);
 144                         return ENOMEM;
 145                 }
 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;
 150                 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);
 159                 ne2k->code.cmds = ne2k_cmds;
 160         }
 161
 162         return register_interrupt_handler(nic_get_ddf_dev(nic_data),
 163             ne2k->irq, ne2k_interrupt_handler, (void *)nic_data, &ne2k->code,
 164             handle);
 165 }
 166
 167 static ddf_dev_ops_t ne2k_dev_ops;
 168
 169 static void ne2k_dev_cleanup(ddf_dev_t *dev)
 170 {
 171         if (ddf_dev_data_get(dev) != NULL) {
 172                 ne2k_t *ne2k = NE2K(dev);
 173                 if (ne2k) {
 174                         free(ne2k->code.ranges);
 175                         free(ne2k->code.cmds);
 176                 }
 177                 nic_unbind_and_destroy(dev);
 178         }
 179 }
 180
 181 static errno_t ne2k_dev_init(nic_t *nic_data)
 182 {
 183         /* Get HW resources */
 184         hw_res_list_parsed_t hw_res_parsed;
 185         hw_res_list_parsed_init(&hw_res_parsed);
 186
 187         errno_t rc = nic_get_resources(nic_data, &hw_res_parsed);
 188
 189         if (rc != EOK)
 190                 goto failed;
 191
 192         if (hw_res_parsed.irqs.count == 0) {
 193                 rc = EINVAL;
 194                 goto failed;
 195         }
 196
 197         if (hw_res_parsed.io_ranges.count == 0) {
 198                 rc = EINVAL;
 199                 goto failed;
 200         }
 201
 202         if (hw_res_parsed.io_ranges.ranges[0].size < NE2K_IO_SIZE) {
 203                 rc = EINVAL;
 204                 goto failed;
 205         }
 206
 207         ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
 208         ne2k->irq = hw_res_parsed.irqs.irqs[0];
 209
 210         addr_range_t regs = hw_res_parsed.io_ranges.ranges[0];
 211         ne2k->base_port = RNGABSPTR(regs);
 212
 213         hw_res_list_parsed_clean(&hw_res_parsed);
 214
 215         /* Enable programmed I/O */
 216         if (pio_enable_range(&regs, &ne2k->port) != EOK)
 217                 return EADDRNOTAVAIL;
 218
 219         ne2k->data_port = ne2k->port + NE2K_DATA;
 220         ne2k->receive_configuration = RCR_AB | RCR_AM;
 221         ne2k->probed = false;
 222         ne2k->up = false;
 223
 224         /* Find out whether the device is present. */
 225         if (ne2k_probe(ne2k) != EOK)
 226                 return ENOENT;
 227
 228         ne2k->probed = true;
 229
 230         if (ne2k_register_interrupt(nic_data, NULL) != EOK)
 231                 return EINVAL;
 232
 233         return EOK;
 234
 235 failed:
 236         hw_res_list_parsed_clean(&hw_res_parsed);
 237         return rc;
 238 }
 239
 240 /** NE2K interrupt handler
 241  *
 242  * @param call IRQ event notification
 243  * @param arg Argument (nic_t *)
 244  */
 245 void ne2k_interrupt_handler(ipc_call_t *call, void *arg)
 246 {
 247         nic_t *nic_data = (nic_t *)arg;
 248         ne2k_interrupt(nic_data, IRQ_GET_ISR(*call), IRQ_GET_TSR(*call));
 249 }
 250
 251 static errno_t ne2k_on_activating(nic_t *nic_data)
 252 {
 253         ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
 254
 255         if (!ne2k->up) {
 256                 errno_t rc = ne2k_up(ne2k);
 257                 if (rc != EOK)
 258                         return rc;
 259
 260                 rc = hw_res_enable_interrupt(ne2k->parent_sess, ne2k->irq);
 261                 if (rc != EOK) {
 262                         ne2k_down(ne2k);
 263                         return rc;
 264                 }
 265         }
 266         return EOK;
 267 }
 268
 269 static errno_t ne2k_on_stopping(nic_t *nic_data)
 270 {
 271         ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
 272
 273         (void) hw_res_disable_interrupt(ne2k->parent_sess, ne2k->irq);
 274         ne2k->receive_configuration = RCR_AB | RCR_AM;
 275         ne2k_down(ne2k);
 276         return EOK;
 277 }
 278
 279 static errno_t ne2k_set_address(ddf_fun_t *fun, const nic_address_t *address)
 280 {
 281         nic_t *nic_data = DRIVER_DATA(ddf_fun_get_dev(fun));
 282         errno_t rc = nic_report_address(nic_data, address);
 283         if (rc != EOK) {
 284                 return EINVAL;
 285         }
 286         /*
 287          * Note: some frame with previous physical address may slip to NIL here
 288          * (for a moment the filtering is not exact), but ethernet should be OK with
 289          * that. Some frames may also be lost, but this is not a problem.
 290          */
 291         ne2k_set_physical_address((ne2k_t *) nic_get_specific(nic_data), address);
 292         return EOK;
 293 }
 294
 295 static errno_t ne2k_get_device_info(ddf_fun_t *fun, nic_device_info_t *info)
 296 {
 297         nic_t *nic_data = nic_get_from_ddf_fun(fun);
 298         if (!nic_data)
 299                 return ENOENT;
 300
 301         str_cpy(info->vendor_name, sizeof(info->vendor_name), "Novell");
 302         str_cpy(info->model_name, sizeof(info->model_name), "NE2000");
 303
 304         return EOK;
 305 }
 306
 307 static errno_t ne2k_get_cable_state(ddf_fun_t *fun, nic_cable_state_t *state)
 308 {
 309         *state = NIC_CS_PLUGGED;
 310         return EOK;
 311 }
 312
 313 static errno_t ne2k_get_operation_mode(ddf_fun_t *fun, int *speed,
 314     nic_channel_mode_t *duplex, nic_role_t *role)
 315 {
 316         *speed = 10;
 317         *duplex = NIC_CM_HALF_DUPLEX;   // XXX
 318         *role = NIC_ROLE_UNKNOWN;
 319         return EOK;
 320 }
 321
 322 static errno_t ne2k_on_unicast_mode_change(nic_t *nic_data,
 323     nic_unicast_mode_t new_mode,
 324     const nic_address_t *address_list, size_t address_count)
 325 {
 326         ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
 327         switch (new_mode) {
 328         case NIC_UNICAST_BLOCKED:
 329                 ne2k_set_promisc_phys(ne2k, false);
 330                 nic_report_hw_filtering(nic_data, 0, -1, -1);
 331                 return EOK;
 332         case NIC_UNICAST_DEFAULT:
 333                 ne2k_set_promisc_phys(ne2k, false);
 334                 nic_report_hw_filtering(nic_data, 1, -1, -1);
 335                 return EOK;
 336         case NIC_UNICAST_LIST:
 337                 ne2k_set_promisc_phys(ne2k, true);
 338                 nic_report_hw_filtering(nic_data, 0, -1, -1);
 339                 return EOK;
 340         case NIC_UNICAST_PROMISC:
 341                 ne2k_set_promisc_phys(ne2k, true);
 342                 nic_report_hw_filtering(nic_data, 1, -1, -1);
 343                 return EOK;
 344         default:
 345                 return ENOTSUP;
 346         }
 347 }
 348
 349 static errno_t ne2k_on_multicast_mode_change(nic_t *nic_data,
 350     nic_multicast_mode_t new_mode,
 351     const nic_address_t *address_list, size_t address_count)
 352 {
 353         ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
 354         switch (new_mode) {
 355         case NIC_MULTICAST_BLOCKED:
 356                 ne2k_set_accept_mcast(ne2k, false);
 357                 nic_report_hw_filtering(nic_data, -1, 1, -1);
 358                 return EOK;
 359         case NIC_MULTICAST_LIST:
 360                 ne2k_set_accept_mcast(ne2k, true);
 361                 ne2k_set_mcast_hash(ne2k,
 362                     nic_mcast_hash(address_list, address_count));
 363                 nic_report_hw_filtering(nic_data, -1, 0, -1);
 364                 return EOK;
 365         case NIC_MULTICAST_PROMISC:
 366                 ne2k_set_accept_mcast(ne2k, true);
 367                 ne2k_set_mcast_hash(ne2k, 0xFFFFFFFFFFFFFFFFllu);
 368                 nic_report_hw_filtering(nic_data, -1, 1, -1);
 369                 return EOK;
 370         default:
 371                 return ENOTSUP;
 372         }
 373 }
 374
 375 static errno_t ne2k_on_broadcast_mode_change(nic_t *nic_data,
 376     nic_broadcast_mode_t new_mode)
 377 {
 378         ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
 379         switch (new_mode) {
 380         case NIC_BROADCAST_BLOCKED:
 381                 ne2k_set_accept_bcast(ne2k, false);
 382                 return EOK;
 383         case NIC_BROADCAST_ACCEPTED:
 384                 ne2k_set_accept_bcast(ne2k, true);
 385                 return EOK;
 386         default:
 387                 return ENOTSUP;
 388         }
 389 }
 390
 391 static errno_t ne2k_dev_add(ddf_dev_t *dev)
 392 {
 393         ddf_fun_t *fun;
 394
 395         /* Allocate driver data for the device. */
 396         nic_t *nic_data = nic_create_and_bind(dev);
 397         if (nic_data == NULL)
 398                 return ENOMEM;
 399
 400         nic_set_send_frame_handler(nic_data, ne2k_send);
 401         nic_set_state_change_handlers(nic_data,
 402             ne2k_on_activating, NULL, ne2k_on_stopping);
 403         nic_set_filtering_change_handlers(nic_data,
 404             ne2k_on_unicast_mode_change, ne2k_on_multicast_mode_change,
 405             ne2k_on_broadcast_mode_change, NULL, NULL);
 406
 407         ne2k_t *ne2k = malloc(sizeof(ne2k_t));
 408         if (NULL != ne2k) {
 409                 memset(ne2k, 0, sizeof(ne2k_t));
 410                 nic_set_specific(nic_data, ne2k);
 411         } else {
 412                 nic_unbind_and_destroy(dev);
 413                 return ENOMEM;
 414         }
 415
 416         ne2k->dev = dev;
 417         ne2k->parent_sess = ddf_dev_parent_sess_get(dev);
 418         if (ne2k->parent_sess == NULL) {
 419                 ne2k_dev_cleanup(dev);
 420                 return ENOMEM;
 421         }
 422
 423         errno_t rc = ne2k_dev_init(nic_data);
 424         if (rc != EOK) {
 425                 ne2k_dev_cleanup(dev);
 426                 return rc;
 427         }
 428
 429         rc = nic_report_address(nic_data, &ne2k->mac);
 430         if (rc != EOK) {
 431                 ne2k_dev_cleanup(dev);
 432                 return rc;
 433         }
 434
 435         fun = ddf_fun_create(nic_get_ddf_dev(nic_data), fun_exposed, "port0");
 436         if (fun == NULL) {
 437                 ne2k_dev_cleanup(dev);
 438                 return ENOMEM;
 439         }
 440
 441         nic_set_ddf_fun(nic_data, fun);
 442         ddf_fun_set_ops(fun, &ne2k_dev_ops);
 443
 444         rc = ddf_fun_bind(fun);
 445         if (rc != EOK) {
 446                 ddf_fun_destroy(fun);
 447                 ne2k_dev_cleanup(dev);
 448                 return rc;
 449         }
 450
 451         rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
 452         if (rc != EOK) {
 453                 ddf_fun_unbind(fun);
 454                 ddf_fun_destroy(fun);
 455                 return rc;
 456         }
 457
 458         return EOK;
 459 }
 460
 461 static nic_iface_t ne2k_nic_iface = {
 462         .set_address = ne2k_set_address,
 463         .get_device_info = ne2k_get_device_info,
 464         .get_cable_state = ne2k_get_cable_state,
 465         .get_operation_mode = ne2k_get_operation_mode,
 466 };
 467
 468 static driver_ops_t ne2k_driver_ops = {
 469         .dev_add = ne2k_dev_add
 470 };
 471
 472 static driver_t ne2k_driver = {
 473         .name = NAME,
 474         .driver_ops = &ne2k_driver_ops
 475 };
 476
 477 int main(int argc, char *argv[])
 478 {
 479         printf("%s: HelenOS NE 2000 network adapter driver\n", NAME);
 480
 481         nic_driver_init(NAME);
 482         nic_driver_implement(&ne2k_driver_ops, &ne2k_dev_ops, &ne2k_nic_iface);
 483
 484         return ddf_driver_main(&ne2k_driver);
 485 }
 486
 487 /** @}
 488  */