Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/mips/cavium/octe/ethernet.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /************************************************************************* 2 Copyright (c) 2003-2007 Cavium Networks (support@cavium.com). All rights 3 reserved. 4 5 6 Redistribution and use in source and binary forms, with or without 7 modification, are permitted provided that the following conditions are 8 met: 9 10 * Redistributions of source code must retain the above copyright 11 notice, this list of conditions and the following disclaimer. 12 13 * Redistributions in binary form must reproduce the above 14 copyright notice, this list of conditions and the following 15 disclaimer in the documentation and/or other materials provided 16 with the distribution. 17 18 * Neither the name of Cavium Networks nor the names of 19 its contributors may be used to endorse or promote products 20 derived from this software without specific prior written 21 permission. 22 23 This Software, including technical data, may be subject to U.S. export control laws, including the U.S. Export Administration Act and its associated regulations, and may be subject to export or import regulations in other countries. 24 25 TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS" 26 AND WITH ALL FAULTS AND CAVIUM NETWORKS MAKES NO PROMISES, REPRESENTATIONS OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO THE SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY REPRESENTATION OR DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT DEFECTS, AND CAVIUM SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY) WARRANTIES OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR CORRESPONDENCE TO DESCRIPTION. THE ENTIRE RISK ARISING OUT OF USE OR PERFORMANCE OF THE SOFTWARE LIES WITH YOU. 27 *************************************************************************/ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/bus.h> 35 #include <sys/conf.h> 36 #include <sys/endian.h> 37 #include <sys/kernel.h> 38 #include <sys/rman.h> 39 #include <sys/mbuf.h> 40 #include <sys/socket.h> 41 #include <sys/module.h> 42 #include <sys/smp.h> 43 #include <sys/taskqueue.h> 44 45 #include <net/ethernet.h> 46 #include <net/if.h> 47 #include <net/if_var.h> 48 #include <net/if_types.h> 49 50 #include "wrapper-cvmx-includes.h" 51 #include "ethernet-headers.h" 52 53 #include "octebusvar.h" 54 55 /* 56 * XXX/juli 57 * Convert 0444 to tunables, 0644 to sysctls. 58 */ 59 #if defined(CONFIG_CAVIUM_OCTEON_NUM_PACKET_BUFFERS) && CONFIG_CAVIUM_OCTEON_NUM_PACKET_BUFFERS 60 int num_packet_buffers = CONFIG_CAVIUM_OCTEON_NUM_PACKET_BUFFERS; 61 #else 62 int num_packet_buffers = 1024; 63 #endif 64 TUNABLE_INT("hw.octe.num_packet_buffers", &num_packet_buffers); 65 /* 66 "\t\tNumber of packet buffers to allocate and store in the\n" 67 "\t\tFPA. By default, 1024 packet buffers are used unless\n" 68 "\t\tCONFIG_CAVIUM_OCTEON_NUM_PACKET_BUFFERS is defined." */ 69 70 int pow_receive_group = 15; 71 TUNABLE_INT("hw.octe.pow_receive_group", &pow_receive_group); 72 /* 73 "\t\tPOW group to receive packets from. All ethernet hardware\n" 74 "\t\twill be configured to send incomming packets to this POW\n" 75 "\t\tgroup. Also any other software can submit packets to this\n" 76 "\t\tgroup for the kernel to process." */ 77 78 /** 79 * Periodic timer to check auto negotiation 80 */ 81 static struct callout cvm_oct_poll_timer; 82 83 /** 84 * Array of every ethernet device owned by this driver indexed by 85 * the ipd input port number. 86 */ 87 struct ifnet *cvm_oct_device[TOTAL_NUMBER_OF_PORTS]; 88 89 /** 90 * Task to handle link status changes. 91 */ 92 static struct taskqueue *cvm_oct_link_taskq; 93 94 /* 95 * Number of buffers in output buffer pool. 96 */ 97 static int cvm_oct_num_output_buffers; 98 99 /** 100 * Function to update link status. 101 */ 102 static void cvm_oct_update_link(void *context, int pending) 103 { 104 cvm_oct_private_t *priv = (cvm_oct_private_t *)context; 105 struct ifnet *ifp = priv->ifp; 106 cvmx_helper_link_info_t link_info; 107 108 link_info.u64 = priv->link_info; 109 110 if (link_info.s.link_up) { 111 if_link_state_change(ifp, LINK_STATE_UP); 112 DEBUGPRINT("%s: %u Mbps %s duplex, port %2d, queue %2d\n", 113 if_name(ifp), link_info.s.speed, 114 (link_info.s.full_duplex) ? "Full" : "Half", 115 priv->port, priv->queue); 116 } else { 117 if_link_state_change(ifp, LINK_STATE_DOWN); 118 DEBUGPRINT("%s: Link down\n", if_name(ifp)); 119 } 120 priv->need_link_update = 0; 121 } 122 123 /** 124 * Periodic timer tick for slow management operations 125 * 126 * @param arg Device to check 127 */ 128 static void cvm_do_timer(void *arg) 129 { 130 static int port; 131 static int updated; 132 if (port < CVMX_PIP_NUM_INPUT_PORTS) { 133 if (cvm_oct_device[port]) { 134 int queues_per_port; 135 int qos; 136 cvm_oct_private_t *priv = (cvm_oct_private_t *)cvm_oct_device[port]->if_softc; 137 138 cvm_oct_common_poll(priv->ifp); 139 if (priv->need_link_update) { 140 updated++; 141 taskqueue_enqueue(cvm_oct_link_taskq, &priv->link_task); 142 } 143 144 queues_per_port = cvmx_pko_get_num_queues(port); 145 /* Drain any pending packets in the free list */ 146 for (qos = 0; qos < queues_per_port; qos++) { 147 if (_IF_QLEN(&priv->tx_free_queue[qos]) > 0) { 148 IF_LOCK(&priv->tx_free_queue[qos]); 149 while (_IF_QLEN(&priv->tx_free_queue[qos]) > cvmx_fau_fetch_and_add32(priv->fau+qos*4, 0)) { 150 struct mbuf *m; 151 152 _IF_DEQUEUE(&priv->tx_free_queue[qos], m); 153 m_freem(m); 154 } 155 IF_UNLOCK(&priv->tx_free_queue[qos]); 156 157 /* 158 * XXX locking! 159 */ 160 priv->ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 161 } 162 } 163 } 164 port++; 165 /* Poll the next port in a 50th of a second. 166 This spreads the polling of ports out a little bit */ 167 callout_reset(&cvm_oct_poll_timer, hz / 50, cvm_do_timer, NULL); 168 } else { 169 port = 0; 170 /* If any updates were made in this run, continue iterating at 171 * 1/50th of a second, so that if a link has merely gone down 172 * temporarily (e.g. because of interface reinitialization) it 173 * will not be forced to stay down for an entire second. 174 */ 175 if (updated > 0) { 176 updated = 0; 177 callout_reset(&cvm_oct_poll_timer, hz / 50, cvm_do_timer, NULL); 178 } else { 179 /* All ports have been polled. Start the next iteration through 180 the ports in one second */ 181 callout_reset(&cvm_oct_poll_timer, hz, cvm_do_timer, NULL); 182 } 183 } 184 } 185 186 /** 187 * Configure common hardware for all interfaces 188 */ 189 static void cvm_oct_configure_common_hw(device_t bus) 190 { 191 struct octebus_softc *sc; 192 int pko_queues; 193 int error; 194 int rid; 195 196 sc = device_get_softc(bus); 197 198 /* Setup the FPA */ 199 cvmx_fpa_enable(); 200 cvm_oct_mem_fill_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE, 201 num_packet_buffers); 202 cvm_oct_mem_fill_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE, 203 num_packet_buffers); 204 if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL) { 205 /* 206 * If the FPA uses different pools for output buffers and 207 * packets, size the output buffer pool based on the number 208 * of PKO queues. 209 */ 210 if (OCTEON_IS_MODEL(OCTEON_CN38XX)) 211 pko_queues = 128; 212 else if (OCTEON_IS_MODEL(OCTEON_CN3XXX)) 213 pko_queues = 32; 214 else if (OCTEON_IS_MODEL(OCTEON_CN50XX)) 215 pko_queues = 32; 216 else 217 pko_queues = 256; 218 219 cvm_oct_num_output_buffers = 4 * pko_queues; 220 cvm_oct_mem_fill_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL, 221 CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 222 cvm_oct_num_output_buffers); 223 } 224 225 if (USE_RED) 226 cvmx_helper_setup_red(num_packet_buffers/4, 227 num_packet_buffers/8); 228 229 /* Enable the MII interface */ 230 if (cvmx_sysinfo_get()->board_type != CVMX_BOARD_TYPE_SIM) 231 cvmx_write_csr(CVMX_SMI_EN, 1); 232 233 /* Register an IRQ hander for to receive POW interrupts */ 234 rid = 0; 235 sc->sc_rx_irq = bus_alloc_resource(bus, SYS_RES_IRQ, &rid, 236 OCTEON_IRQ_WORKQ0 + pow_receive_group, 237 OCTEON_IRQ_WORKQ0 + pow_receive_group, 238 1, RF_ACTIVE); 239 if (sc->sc_rx_irq == NULL) { 240 device_printf(bus, "could not allocate workq irq"); 241 return; 242 } 243 244 error = bus_setup_intr(bus, sc->sc_rx_irq, INTR_TYPE_NET | INTR_MPSAFE, 245 cvm_oct_do_interrupt, NULL, cvm_oct_device, 246 &sc->sc_rx_intr_cookie); 247 if (error != 0) { 248 device_printf(bus, "could not setup workq irq"); 249 return; 250 } 251 252 253 #ifdef SMP 254 { 255 cvmx_ciu_intx0_t en; 256 int core; 257 258 CPU_FOREACH(core) { 259 if (core == PCPU_GET(cpuid)) 260 continue; 261 262 en.u64 = cvmx_read_csr(CVMX_CIU_INTX_EN0(core*2)); 263 en.s.workq |= (1<<pow_receive_group); 264 cvmx_write_csr(CVMX_CIU_INTX_EN0(core*2), en.u64); 265 } 266 } 267 #endif 268 } 269 270 271 /** 272 * Free a work queue entry received in a intercept callback. 273 * 274 * @param work_queue_entry 275 * Work queue entry to free 276 * @return Zero on success, Negative on failure. 277 */ 278 int cvm_oct_free_work(void *work_queue_entry) 279 { 280 cvmx_wqe_t *work = work_queue_entry; 281 282 int segments = work->word2.s.bufs; 283 cvmx_buf_ptr_t segment_ptr = work->packet_ptr; 284 285 while (segments--) { 286 cvmx_buf_ptr_t next_ptr = *(cvmx_buf_ptr_t *)cvmx_phys_to_ptr(segment_ptr.s.addr-8); 287 if (__predict_false(!segment_ptr.s.i)) 288 cvmx_fpa_free(cvm_oct_get_buffer_ptr(segment_ptr), segment_ptr.s.pool, DONT_WRITEBACK(CVMX_FPA_PACKET_POOL_SIZE/128)); 289 segment_ptr = next_ptr; 290 } 291 cvmx_fpa_free(work, CVMX_FPA_WQE_POOL, DONT_WRITEBACK(1)); 292 293 return 0; 294 } 295 296 297 /** 298 * Module/ driver initialization. Creates the linux network 299 * devices. 300 * 301 * @return Zero on success 302 */ 303 int cvm_oct_init_module(device_t bus) 304 { 305 device_t dev; 306 int ifnum; 307 int num_interfaces; 308 int interface; 309 int fau = FAU_NUM_PACKET_BUFFERS_TO_FREE; 310 int qos; 311 312 cvm_oct_rx_initialize(); 313 cvm_oct_configure_common_hw(bus); 314 315 cvmx_helper_initialize_packet_io_global(); 316 317 /* Change the input group for all ports before input is enabled */ 318 num_interfaces = cvmx_helper_get_number_of_interfaces(); 319 for (interface = 0; interface < num_interfaces; interface++) { 320 int num_ports = cvmx_helper_ports_on_interface(interface); 321 int port; 322 323 for (port = 0; port < num_ports; port++) { 324 cvmx_pip_prt_tagx_t pip_prt_tagx; 325 int pkind = cvmx_helper_get_ipd_port(interface, port); 326 327 pip_prt_tagx.u64 = cvmx_read_csr(CVMX_PIP_PRT_TAGX(pkind)); 328 pip_prt_tagx.s.grp = pow_receive_group; 329 cvmx_write_csr(CVMX_PIP_PRT_TAGX(pkind), pip_prt_tagx.u64); 330 } 331 } 332 333 cvmx_helper_ipd_and_packet_input_enable(); 334 335 memset(cvm_oct_device, 0, sizeof(cvm_oct_device)); 336 337 cvm_oct_link_taskq = taskqueue_create("octe link", M_NOWAIT, 338 taskqueue_thread_enqueue, &cvm_oct_link_taskq); 339 taskqueue_start_threads(&cvm_oct_link_taskq, 1, PI_NET, 340 "octe link taskq"); 341 342 /* Initialize the FAU used for counting packet buffers that need to be freed */ 343 cvmx_fau_atomic_write32(FAU_NUM_PACKET_BUFFERS_TO_FREE, 0); 344 345 ifnum = 0; 346 num_interfaces = cvmx_helper_get_number_of_interfaces(); 347 for (interface = 0; interface < num_interfaces; interface++) { 348 cvmx_helper_interface_mode_t imode = cvmx_helper_interface_get_mode(interface); 349 int num_ports = cvmx_helper_ports_on_interface(interface); 350 int port; 351 352 for (port = cvmx_helper_get_ipd_port(interface, 0); 353 port < cvmx_helper_get_ipd_port(interface, num_ports); 354 ifnum++, port++) { 355 cvm_oct_private_t *priv; 356 struct ifnet *ifp; 357 358 dev = BUS_ADD_CHILD(bus, 0, "octe", ifnum); 359 if (dev != NULL) 360 ifp = if_alloc(IFT_ETHER); 361 if (dev == NULL || ifp == NULL) { 362 printf("Failed to allocate ethernet device for interface %d port %d\n", interface, port); 363 continue; 364 } 365 366 /* Initialize the device private structure. */ 367 device_probe(dev); 368 priv = device_get_softc(dev); 369 priv->dev = dev; 370 priv->ifp = ifp; 371 priv->imode = imode; 372 priv->port = port; 373 priv->queue = cvmx_pko_get_base_queue(priv->port); 374 priv->fau = fau - cvmx_pko_get_num_queues(port) * 4; 375 for (qos = 0; qos < cvmx_pko_get_num_queues(port); qos++) 376 cvmx_fau_atomic_write32(priv->fau+qos*4, 0); 377 TASK_INIT(&priv->link_task, 0, cvm_oct_update_link, priv); 378 379 switch (priv->imode) { 380 381 /* These types don't support ports to IPD/PKO */ 382 case CVMX_HELPER_INTERFACE_MODE_DISABLED: 383 case CVMX_HELPER_INTERFACE_MODE_PCIE: 384 case CVMX_HELPER_INTERFACE_MODE_PICMG: 385 break; 386 387 case CVMX_HELPER_INTERFACE_MODE_NPI: 388 priv->init = cvm_oct_common_init; 389 priv->uninit = cvm_oct_common_uninit; 390 device_set_desc(dev, "Cavium Octeon NPI Ethernet"); 391 break; 392 393 case CVMX_HELPER_INTERFACE_MODE_XAUI: 394 priv->init = cvm_oct_xaui_init; 395 priv->uninit = cvm_oct_common_uninit; 396 device_set_desc(dev, "Cavium Octeon XAUI Ethernet"); 397 break; 398 399 case CVMX_HELPER_INTERFACE_MODE_LOOP: 400 priv->init = cvm_oct_common_init; 401 priv->uninit = cvm_oct_common_uninit; 402 device_set_desc(dev, "Cavium Octeon LOOP Ethernet"); 403 break; 404 405 case CVMX_HELPER_INTERFACE_MODE_SGMII: 406 priv->init = cvm_oct_sgmii_init; 407 priv->uninit = cvm_oct_common_uninit; 408 device_set_desc(dev, "Cavium Octeon SGMII Ethernet"); 409 break; 410 411 case CVMX_HELPER_INTERFACE_MODE_SPI: 412 priv->init = cvm_oct_spi_init; 413 priv->uninit = cvm_oct_spi_uninit; 414 device_set_desc(dev, "Cavium Octeon SPI Ethernet"); 415 break; 416 417 case CVMX_HELPER_INTERFACE_MODE_RGMII: 418 priv->init = cvm_oct_rgmii_init; 419 priv->uninit = cvm_oct_rgmii_uninit; 420 device_set_desc(dev, "Cavium Octeon RGMII Ethernet"); 421 break; 422 423 case CVMX_HELPER_INTERFACE_MODE_GMII: 424 priv->init = cvm_oct_rgmii_init; 425 priv->uninit = cvm_oct_rgmii_uninit; 426 device_set_desc(dev, "Cavium Octeon GMII Ethernet"); 427 break; 428 } 429 430 ifp->if_softc = priv; 431 432 if (!priv->init) { 433 printf("octe%d: unsupported device type interface %d, port %d\n", 434 ifnum, interface, priv->port); 435 if_free(ifp); 436 } else if (priv->init(ifp) != 0) { 437 printf("octe%d: failed to register device for interface %d, port %d\n", 438 ifnum, interface, priv->port); 439 if_free(ifp); 440 } else { 441 cvm_oct_device[priv->port] = ifp; 442 fau -= cvmx_pko_get_num_queues(priv->port) * sizeof(uint32_t); 443 } 444 } 445 } 446 447 if (INTERRUPT_LIMIT) { 448 /* Set the POW timer rate to give an interrupt at most INTERRUPT_LIMIT times per second */ 449 cvmx_write_csr(CVMX_POW_WQ_INT_PC, cvmx_clock_get_rate(CVMX_CLOCK_CORE)/(INTERRUPT_LIMIT*16*256)<<8); 450 451 /* Enable POW timer interrupt. It will count when there are packets available */ 452 cvmx_write_csr(CVMX_POW_WQ_INT_THRX(pow_receive_group), 0x1ful<<24); 453 } else { 454 /* Enable POW interrupt when our port has at least one packet */ 455 cvmx_write_csr(CVMX_POW_WQ_INT_THRX(pow_receive_group), 0x1001); 456 } 457 458 callout_init(&cvm_oct_poll_timer, 1); 459 callout_reset(&cvm_oct_poll_timer, hz, cvm_do_timer, NULL); 460 461 return 0; 462 } 463 464 465 /** 466 * Module / driver shutdown 467 * 468 * @return Zero on success 469 */ 470 void cvm_oct_cleanup_module(device_t bus) 471 { 472 int port; 473 struct octebus_softc *sc = device_get_softc(bus); 474 475 /* Disable POW interrupt */ 476 cvmx_write_csr(CVMX_POW_WQ_INT_THRX(pow_receive_group), 0); 477 478 /* Free the interrupt handler */ 479 bus_teardown_intr(bus, sc->sc_rx_irq, sc->sc_rx_intr_cookie); 480 481 callout_stop(&cvm_oct_poll_timer); 482 cvm_oct_rx_shutdown(); 483 484 cvmx_helper_shutdown_packet_io_global(); 485 486 /* Free the ethernet devices */ 487 for (port = 0; port < TOTAL_NUMBER_OF_PORTS; port++) { 488 if (cvm_oct_device[port]) { 489 cvm_oct_tx_shutdown(cvm_oct_device[port]); 490 #if 0 491 unregister_netdev(cvm_oct_device[port]); 492 kfree(cvm_oct_device[port]); 493 #else 494 panic("%s: need to detach and free interface.", __func__); 495 #endif 496 cvm_oct_device[port] = NULL; 497 } 498 } 499 /* Free the HW pools */ 500 cvm_oct_mem_empty_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE, num_packet_buffers); 501 cvm_oct_mem_empty_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE, num_packet_buffers); 502 503 if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL) 504 cvm_oct_mem_empty_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL, CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, cvm_oct_num_output_buffers); 505 506 /* Disable FPA, all buffers are free, not done by helper shutdown. */ 507 cvmx_fpa_disable(); 508 }
Cache object: 13f58181bf89fd6e3352f409919627f9
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]