1/*- 2 * Copyright (c) 2010-2011 Juli Mallett <jmallett@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 *
| 1/*- 2 * Copyright (c) 2010-2011 Juli Mallett <jmallett@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 *
|
26 * $FreeBSD: head/sys/mips/cavium/if_octm.c 231987 2012-02-22 01:30:25Z gonzo $
| 26 * $FreeBSD: head/sys/mips/cavium/if_octm.c 232289 2012-02-29 05:48:29Z gonzo $
|
27 */ 28 29/* 30 * Cavium Octeon management port Ethernet devices. 31 */ 32 33#include "opt_inet.h" 34 35#include <sys/param.h> 36#include <sys/systm.h> 37#include <sys/bus.h> 38#include <sys/endian.h> 39#include <sys/kernel.h> 40#include <sys/mbuf.h> 41#include <sys/lock.h> 42#include <sys/module.h> 43#include <sys/mutex.h> 44#include <sys/rman.h> 45#include <sys/socket.h> 46#include <sys/sockio.h> 47#include <sys/sysctl.h> 48 49#include <net/bpf.h> 50#include <net/ethernet.h> 51#include <net/if.h> 52#include <net/if_dl.h> 53#include <net/if_media.h> 54#include <net/if_types.h> 55#include <net/if_var.h> 56#include <net/if_vlan_var.h> 57 58#ifdef INET 59#include <netinet/in.h> 60#include <netinet/if_ether.h> 61#endif 62 63#include <contrib/octeon-sdk/cvmx.h> 64#include <contrib/octeon-sdk/cvmx-interrupt.h> 65#include <contrib/octeon-sdk/cvmx-mgmt-port.h>
| 27 */ 28 29/* 30 * Cavium Octeon management port Ethernet devices. 31 */ 32 33#include "opt_inet.h" 34 35#include <sys/param.h> 36#include <sys/systm.h> 37#include <sys/bus.h> 38#include <sys/endian.h> 39#include <sys/kernel.h> 40#include <sys/mbuf.h> 41#include <sys/lock.h> 42#include <sys/module.h> 43#include <sys/mutex.h> 44#include <sys/rman.h> 45#include <sys/socket.h> 46#include <sys/sockio.h> 47#include <sys/sysctl.h> 48 49#include <net/bpf.h> 50#include <net/ethernet.h> 51#include <net/if.h> 52#include <net/if_dl.h> 53#include <net/if_media.h> 54#include <net/if_types.h> 55#include <net/if_var.h> 56#include <net/if_vlan_var.h> 57 58#ifdef INET 59#include <netinet/in.h> 60#include <netinet/if_ether.h> 61#endif 62 63#include <contrib/octeon-sdk/cvmx.h> 64#include <contrib/octeon-sdk/cvmx-interrupt.h> 65#include <contrib/octeon-sdk/cvmx-mgmt-port.h>
|
66#include "octe/ethernet-common.h"
| |
67 68struct octm_softc { 69 struct ifnet *sc_ifp; 70 device_t sc_dev; 71 unsigned sc_port; 72 int sc_flags; 73 struct ifmedia sc_ifmedia; 74 struct resource *sc_intr; 75 void *sc_intr_cookie; 76}; 77 78static void octm_identify(driver_t *, device_t); 79static int octm_probe(device_t); 80static int octm_attach(device_t); 81static int octm_detach(device_t); 82static int octm_shutdown(device_t); 83 84static void octm_init(void *); 85static int octm_transmit(struct ifnet *, struct mbuf *); 86 87static int octm_medchange(struct ifnet *); 88static void octm_medstat(struct ifnet *, struct ifmediareq *); 89 90static int octm_ioctl(struct ifnet *, u_long, caddr_t); 91 92static void octm_rx_intr(void *); 93 94static device_method_t octm_methods[] = { 95 /* Device interface */ 96 DEVMETHOD(device_identify, octm_identify), 97 DEVMETHOD(device_probe, octm_probe), 98 DEVMETHOD(device_attach, octm_attach), 99 DEVMETHOD(device_detach, octm_detach), 100 DEVMETHOD(device_shutdown, octm_shutdown), 101 102 { 0, 0 } 103}; 104 105static driver_t octm_driver = { 106 "octm", 107 octm_methods, 108 sizeof (struct octm_softc), 109}; 110 111static devclass_t octm_devclass; 112 113DRIVER_MODULE(octm, ciu, octm_driver, octm_devclass, 0, 0); 114 115static void 116octm_identify(driver_t *drv, device_t parent) 117{ 118 unsigned i; 119 120 if (!octeon_has_feature(OCTEON_FEATURE_MGMT_PORT)) 121 return; 122 123 for (i = 0; i < CVMX_MGMT_PORT_NUM_PORTS; i++) 124 BUS_ADD_CHILD(parent, 0, "octm", i); 125} 126 127static int 128octm_probe(device_t dev) 129{ 130 cvmx_mgmt_port_result_t result; 131 132 result = cvmx_mgmt_port_initialize(device_get_unit(dev)); 133 switch (result) { 134 case CVMX_MGMT_PORT_SUCCESS: 135 break; 136 case CVMX_MGMT_PORT_NO_MEMORY: 137 return (ENOBUFS); 138 case CVMX_MGMT_PORT_INVALID_PARAM: 139 return (ENXIO); 140 case CVMX_MGMT_PORT_INIT_ERROR: 141 return (EIO); 142 } 143 144 device_set_desc(dev, "Cavium Octeon Management Ethernet"); 145 146 return (0); 147} 148 149static int 150octm_attach(device_t dev) 151{ 152 struct ifnet *ifp; 153 struct octm_softc *sc; 154 cvmx_mixx_irhwm_t mixx_irhwm; 155 cvmx_mixx_intena_t mixx_intena; 156 uint64_t mac; 157 int error; 158 int irq; 159 int rid; 160 161 sc = device_get_softc(dev); 162 sc->sc_dev = dev; 163 sc->sc_port = device_get_unit(dev); 164 165 switch (sc->sc_port) { 166 case 0: 167 irq = CVMX_IRQ_MII; 168 break; 169 case 1: 170 irq = CVMX_IRQ_MII1; 171 break; 172 default: 173 device_printf(dev, "unsupported management port %u.\n", sc->sc_port); 174 return (ENXIO); 175 } 176 177 /* 178 * Set MAC address for this management port. 179 */
| 66 67struct octm_softc { 68 struct ifnet *sc_ifp; 69 device_t sc_dev; 70 unsigned sc_port; 71 int sc_flags; 72 struct ifmedia sc_ifmedia; 73 struct resource *sc_intr; 74 void *sc_intr_cookie; 75}; 76 77static void octm_identify(driver_t *, device_t); 78static int octm_probe(device_t); 79static int octm_attach(device_t); 80static int octm_detach(device_t); 81static int octm_shutdown(device_t); 82 83static void octm_init(void *); 84static int octm_transmit(struct ifnet *, struct mbuf *); 85 86static int octm_medchange(struct ifnet *); 87static void octm_medstat(struct ifnet *, struct ifmediareq *); 88 89static int octm_ioctl(struct ifnet *, u_long, caddr_t); 90 91static void octm_rx_intr(void *); 92 93static device_method_t octm_methods[] = { 94 /* Device interface */ 95 DEVMETHOD(device_identify, octm_identify), 96 DEVMETHOD(device_probe, octm_probe), 97 DEVMETHOD(device_attach, octm_attach), 98 DEVMETHOD(device_detach, octm_detach), 99 DEVMETHOD(device_shutdown, octm_shutdown), 100 101 { 0, 0 } 102}; 103 104static driver_t octm_driver = { 105 "octm", 106 octm_methods, 107 sizeof (struct octm_softc), 108}; 109 110static devclass_t octm_devclass; 111 112DRIVER_MODULE(octm, ciu, octm_driver, octm_devclass, 0, 0); 113 114static void 115octm_identify(driver_t *drv, device_t parent) 116{ 117 unsigned i; 118 119 if (!octeon_has_feature(OCTEON_FEATURE_MGMT_PORT)) 120 return; 121 122 for (i = 0; i < CVMX_MGMT_PORT_NUM_PORTS; i++) 123 BUS_ADD_CHILD(parent, 0, "octm", i); 124} 125 126static int 127octm_probe(device_t dev) 128{ 129 cvmx_mgmt_port_result_t result; 130 131 result = cvmx_mgmt_port_initialize(device_get_unit(dev)); 132 switch (result) { 133 case CVMX_MGMT_PORT_SUCCESS: 134 break; 135 case CVMX_MGMT_PORT_NO_MEMORY: 136 return (ENOBUFS); 137 case CVMX_MGMT_PORT_INVALID_PARAM: 138 return (ENXIO); 139 case CVMX_MGMT_PORT_INIT_ERROR: 140 return (EIO); 141 } 142 143 device_set_desc(dev, "Cavium Octeon Management Ethernet"); 144 145 return (0); 146} 147 148static int 149octm_attach(device_t dev) 150{ 151 struct ifnet *ifp; 152 struct octm_softc *sc; 153 cvmx_mixx_irhwm_t mixx_irhwm; 154 cvmx_mixx_intena_t mixx_intena; 155 uint64_t mac; 156 int error; 157 int irq; 158 int rid; 159 160 sc = device_get_softc(dev); 161 sc->sc_dev = dev; 162 sc->sc_port = device_get_unit(dev); 163 164 switch (sc->sc_port) { 165 case 0: 166 irq = CVMX_IRQ_MII; 167 break; 168 case 1: 169 irq = CVMX_IRQ_MII1; 170 break; 171 default: 172 device_printf(dev, "unsupported management port %u.\n", sc->sc_port); 173 return (ENXIO); 174 } 175 176 /* 177 * Set MAC address for this management port. 178 */
|
180 if (cvm_assign_mac_address(&mac, NULL) != 0) { 181 device_printf(dev, "unable to allocate MAC address.\n"); 182 return (ENXIO); 183 }
| 179 mac = 0; 180 memcpy((u_int8_t *)&mac + 2, cvmx_sysinfo_get()->mac_addr_base, 6); 181 mac += sc->sc_port; 182
|
184 cvmx_mgmt_port_set_mac(sc->sc_port, mac); 185 186 /* No watermark for input ring. */ 187 mixx_irhwm.u64 = 0; 188 cvmx_write_csr(CVMX_MIXX_IRHWM(sc->sc_port), mixx_irhwm.u64); 189 190 /* Enable input ring interrupts. */ 191 mixx_intena.u64 = 0; 192 mixx_intena.s.ithena = 1; 193 cvmx_write_csr(CVMX_MIXX_INTENA(sc->sc_port), mixx_intena.u64); 194 195 /* Allocate and establish interrupt. */ 196 rid = 0; 197 sc->sc_intr = bus_alloc_resource(sc->sc_dev, SYS_RES_IRQ, &rid, 198 irq, irq, 1, RF_ACTIVE); 199 if (sc->sc_intr == NULL) { 200 device_printf(dev, "unable to allocate IRQ.\n"); 201 return (ENXIO); 202 } 203 204 error = bus_setup_intr(sc->sc_dev, sc->sc_intr, INTR_TYPE_NET, NULL, 205 octm_rx_intr, sc, &sc->sc_intr_cookie); 206 if (error != 0) { 207 device_printf(dev, "unable to setup interrupt.\n"); 208 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_intr); 209 return (ENXIO); 210 } 211 212 bus_describe_intr(sc->sc_dev, sc->sc_intr, sc->sc_intr_cookie, "rx"); 213 214 /* XXX Possibly should enable TX interrupts. */ 215 216 ifp = if_alloc(IFT_ETHER); 217 if (ifp == NULL) { 218 device_printf(dev, "cannot allocate ifnet.\n"); 219 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_intr); 220 return (ENOMEM); 221 } 222 223 if_initname(ifp, device_get_name(dev), device_get_unit(dev)); 224 ifp->if_mtu = ETHERMTU; 225 ifp->if_init = octm_init; 226 ifp->if_softc = sc; 227 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST | IFF_ALLMULTI; 228 ifp->if_ioctl = octm_ioctl; 229 230 sc->sc_ifp = ifp; 231 sc->sc_flags = ifp->if_flags; 232 233 ifmedia_init(&sc->sc_ifmedia, 0, octm_medchange, octm_medstat); 234 235 ifmedia_add(&sc->sc_ifmedia, IFM_ETHER | IFM_AUTO, 0, NULL); 236 ifmedia_set(&sc->sc_ifmedia, IFM_ETHER | IFM_AUTO); 237 238 ether_ifattach(ifp, (const u_int8_t *)&mac + 2); 239 240 ifp->if_transmit = octm_transmit; 241 242 ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header); 243 ifp->if_capabilities = IFCAP_VLAN_MTU; 244 ifp->if_capenable = ifp->if_capabilities; 245 246 IFQ_SET_MAXLEN(&ifp->if_snd, CVMX_MGMT_PORT_NUM_TX_BUFFERS); 247 ifp->if_snd.ifq_drv_maxlen = CVMX_MGMT_PORT_NUM_TX_BUFFERS; 248 IFQ_SET_READY(&ifp->if_snd); 249 250 return (bus_generic_attach(dev)); 251} 252 253static int 254octm_detach(device_t dev) 255{ 256 struct octm_softc *sc; 257 cvmx_mgmt_port_result_t result; 258 259 sc = device_get_softc(dev); 260 261 result = cvmx_mgmt_port_initialize(sc->sc_port); 262 switch (result) { 263 case CVMX_MGMT_PORT_SUCCESS: 264 break; 265 case CVMX_MGMT_PORT_NO_MEMORY: 266 return (ENOBUFS); 267 case CVMX_MGMT_PORT_INVALID_PARAM: 268 return (ENXIO); 269 case CVMX_MGMT_PORT_INIT_ERROR: 270 return (EIO); 271 } 272 273 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_intr); 274 /* XXX Incomplete. */ 275 276 return (0); 277} 278 279static int 280octm_shutdown(device_t dev) 281{ 282 return (octm_detach(dev)); 283} 284 285static void 286octm_init(void *arg) 287{ 288 struct ifnet *ifp; 289 struct octm_softc *sc; 290 cvmx_mgmt_port_netdevice_flags_t flags; 291 uint64_t mac; 292 293 sc = arg; 294 ifp = sc->sc_ifp; 295 296 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) { 297 cvmx_mgmt_port_disable(sc->sc_port); 298 299 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 300 } 301 302 if (((ifp->if_flags ^ sc->sc_flags) & (IFF_ALLMULTI | IFF_MULTICAST | IFF_PROMISC)) != 0) { 303 flags = 0; 304 if ((ifp->if_flags & IFF_ALLMULTI) != 0) 305 flags |= CVMX_IFF_ALLMULTI; 306 if ((ifp->if_flags & IFF_PROMISC) != 0) 307 flags |= CVMX_IFF_PROMISC; 308 cvmx_mgmt_port_set_multicast_list(sc->sc_port, flags); 309 } 310 311 mac = 0; 312 memcpy((u_int8_t *)&mac + 2, IF_LLADDR(ifp), 6); 313 cvmx_mgmt_port_set_mac(sc->sc_port, mac); 314 315 /* XXX link state? */ 316 317 if ((ifp->if_flags & IFF_UP) != 0) 318 cvmx_mgmt_port_enable(sc->sc_port); 319 320 ifp->if_drv_flags |= IFF_DRV_RUNNING; 321 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 322} 323 324static int 325octm_transmit(struct ifnet *ifp, struct mbuf *m) 326{ 327 struct octm_softc *sc; 328 cvmx_mgmt_port_result_t result; 329 330 sc = ifp->if_softc; 331 332 if ((ifp->if_drv_flags & (IFF_DRV_RUNNING | IFF_DRV_OACTIVE)) != 333 IFF_DRV_RUNNING) { 334 m_freem(m); 335 return (0); 336 } 337 338 result = cvmx_mgmt_port_sendm(sc->sc_port, m); 339 340 if (result == CVMX_MGMT_PORT_SUCCESS) { 341 ETHER_BPF_MTAP(ifp, m); 342 343 ifp->if_opackets++; 344 ifp->if_obytes += m->m_pkthdr.len; 345 } else 346 ifp->if_oerrors++; 347 348 m_freem(m); 349 350 switch (result) { 351 case CVMX_MGMT_PORT_SUCCESS: 352 return (0); 353 case CVMX_MGMT_PORT_NO_MEMORY: 354 return (ENOBUFS); 355 case CVMX_MGMT_PORT_INVALID_PARAM: 356 return (ENXIO); 357 case CVMX_MGMT_PORT_INIT_ERROR: 358 return (EIO); 359 default: 360 return (EDOOFUS); 361 } 362} 363 364static int 365octm_medchange(struct ifnet *ifp) 366{ 367 return (ENOTSUP); 368} 369 370static void 371octm_medstat(struct ifnet *ifp, struct ifmediareq *ifm) 372{ 373 struct octm_softc *sc; 374 cvmx_helper_link_info_t link_info; 375 376 sc = ifp->if_softc; 377 378 ifm->ifm_status = IFM_AVALID; 379 ifm->ifm_active = IFT_ETHER; 380 381 link_info = cvmx_mgmt_port_link_get(sc->sc_port); 382 if (!link_info.s.link_up) 383 return; 384 385 ifm->ifm_status |= IFM_ACTIVE; 386 387 switch (link_info.s.speed) { 388 case 10: 389 ifm->ifm_active |= IFM_10_T; 390 break; 391 case 100: 392 ifm->ifm_active |= IFM_100_TX; 393 break; 394 case 1000: 395 ifm->ifm_active |= IFM_1000_T; 396 break; 397 case 10000: 398 ifm->ifm_active |= IFM_10G_T; 399 break; 400 } 401 402 if (link_info.s.full_duplex) 403 ifm->ifm_active |= IFM_FDX; 404 else 405 ifm->ifm_active |= IFM_HDX; 406} 407 408static int 409octm_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 410{ 411 struct octm_softc *sc; 412 struct ifreq *ifr; 413#ifdef INET 414 struct ifaddr *ifa; 415#endif 416 int error; 417 418 sc = ifp->if_softc; 419 ifr = (struct ifreq *)data; 420#ifdef INET 421 ifa = (struct ifaddr *)data; 422#endif 423 424 switch (cmd) { 425 case SIOCSIFADDR: 426#ifdef INET 427 /* 428 * Avoid reinitialization unless it's necessary. 429 */ 430 if (ifa->ifa_addr->sa_family == AF_INET) { 431 ifp->if_flags |= IFF_UP; 432 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) 433 octm_init(sc); 434 arp_ifinit(ifp, ifa); 435 436 return (0); 437 } 438#endif 439 error = ether_ioctl(ifp, cmd, data); 440 if (error != 0) 441 return (error); 442 return (0); 443 444 case SIOCSIFFLAGS: 445 if (ifp->if_flags == sc->sc_flags) 446 return (0); 447 if ((ifp->if_flags & IFF_UP) != 0) { 448 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) 449 octm_init(sc); 450 } else { 451 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) { 452 cvmx_mgmt_port_disable(sc->sc_port); 453 454 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 455 } 456 } 457 sc->sc_flags = ifp->if_flags; 458 return (0); 459 460 case SIOCSIFCAP: 461 /* 462 * Just change the capabilities in software, currently none 463 * require reprogramming hardware, they just toggle whether we 464 * make use of already-present facilities in software. 465 */ 466 ifp->if_capenable = ifr->ifr_reqcap; 467 return (0); 468 469 case SIOCSIFMTU: 470 cvmx_mgmt_port_set_max_packet_size(sc->sc_port, ifr->ifr_mtu + ifp->if_data.ifi_hdrlen); 471 return (0); 472 473 case SIOCSIFMEDIA: 474 case SIOCGIFMEDIA: 475 error = ifmedia_ioctl(ifp, ifr, &sc->sc_ifmedia, cmd); 476 if (error != 0) 477 return (error); 478 return (0); 479 480 default: 481 error = ether_ioctl(ifp, cmd, data); 482 if (error != 0) 483 return (error); 484 return (0); 485 } 486} 487 488static void 489octm_rx_intr(void *arg) 490{ 491 struct octm_softc *sc = arg; 492 cvmx_mixx_isr_t mixx_isr; 493 int len; 494 495 mixx_isr.u64 = cvmx_read_csr(CVMX_MIXX_ISR(sc->sc_port)); 496 if (!mixx_isr.s.irthresh) { 497 device_printf(sc->sc_dev, "stray interrupt.\n"); 498 return; 499 } 500 501 for (;;) { 502 struct mbuf *m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); 503 if (m == NULL) { 504 device_printf(sc->sc_dev, "no memory for receive mbuf.\n"); 505 return; 506 } 507 508 509 len = cvmx_mgmt_port_receive(sc->sc_port, MCLBYTES, m->m_data); 510 if (len > 0) { 511 m->m_pkthdr.rcvif = sc->sc_ifp; 512 m->m_pkthdr.len = m->m_len = len; 513 514 sc->sc_ifp->if_ipackets++; 515 516 (*sc->sc_ifp->if_input)(sc->sc_ifp, m); 517 518 continue; 519 } 520 521 m_freem(m); 522 523 if (len == 0) 524 break; 525 526 sc->sc_ifp->if_ierrors++; 527 } 528 529 /* Acknowledge interrupts. */ 530 cvmx_write_csr(CVMX_MIXX_ISR(sc->sc_port), mixx_isr.u64); 531 cvmx_read_csr(CVMX_MIXX_ISR(sc->sc_port)); 532}
| 183 cvmx_mgmt_port_set_mac(sc->sc_port, mac); 184 185 /* No watermark for input ring. */ 186 mixx_irhwm.u64 = 0; 187 cvmx_write_csr(CVMX_MIXX_IRHWM(sc->sc_port), mixx_irhwm.u64); 188 189 /* Enable input ring interrupts. */ 190 mixx_intena.u64 = 0; 191 mixx_intena.s.ithena = 1; 192 cvmx_write_csr(CVMX_MIXX_INTENA(sc->sc_port), mixx_intena.u64); 193 194 /* Allocate and establish interrupt. */ 195 rid = 0; 196 sc->sc_intr = bus_alloc_resource(sc->sc_dev, SYS_RES_IRQ, &rid, 197 irq, irq, 1, RF_ACTIVE); 198 if (sc->sc_intr == NULL) { 199 device_printf(dev, "unable to allocate IRQ.\n"); 200 return (ENXIO); 201 } 202 203 error = bus_setup_intr(sc->sc_dev, sc->sc_intr, INTR_TYPE_NET, NULL, 204 octm_rx_intr, sc, &sc->sc_intr_cookie); 205 if (error != 0) { 206 device_printf(dev, "unable to setup interrupt.\n"); 207 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_intr); 208 return (ENXIO); 209 } 210 211 bus_describe_intr(sc->sc_dev, sc->sc_intr, sc->sc_intr_cookie, "rx"); 212 213 /* XXX Possibly should enable TX interrupts. */ 214 215 ifp = if_alloc(IFT_ETHER); 216 if (ifp == NULL) { 217 device_printf(dev, "cannot allocate ifnet.\n"); 218 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_intr); 219 return (ENOMEM); 220 } 221 222 if_initname(ifp, device_get_name(dev), device_get_unit(dev)); 223 ifp->if_mtu = ETHERMTU; 224 ifp->if_init = octm_init; 225 ifp->if_softc = sc; 226 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST | IFF_ALLMULTI; 227 ifp->if_ioctl = octm_ioctl; 228 229 sc->sc_ifp = ifp; 230 sc->sc_flags = ifp->if_flags; 231 232 ifmedia_init(&sc->sc_ifmedia, 0, octm_medchange, octm_medstat); 233 234 ifmedia_add(&sc->sc_ifmedia, IFM_ETHER | IFM_AUTO, 0, NULL); 235 ifmedia_set(&sc->sc_ifmedia, IFM_ETHER | IFM_AUTO); 236 237 ether_ifattach(ifp, (const u_int8_t *)&mac + 2); 238 239 ifp->if_transmit = octm_transmit; 240 241 ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header); 242 ifp->if_capabilities = IFCAP_VLAN_MTU; 243 ifp->if_capenable = ifp->if_capabilities; 244 245 IFQ_SET_MAXLEN(&ifp->if_snd, CVMX_MGMT_PORT_NUM_TX_BUFFERS); 246 ifp->if_snd.ifq_drv_maxlen = CVMX_MGMT_PORT_NUM_TX_BUFFERS; 247 IFQ_SET_READY(&ifp->if_snd); 248 249 return (bus_generic_attach(dev)); 250} 251 252static int 253octm_detach(device_t dev) 254{ 255 struct octm_softc *sc; 256 cvmx_mgmt_port_result_t result; 257 258 sc = device_get_softc(dev); 259 260 result = cvmx_mgmt_port_initialize(sc->sc_port); 261 switch (result) { 262 case CVMX_MGMT_PORT_SUCCESS: 263 break; 264 case CVMX_MGMT_PORT_NO_MEMORY: 265 return (ENOBUFS); 266 case CVMX_MGMT_PORT_INVALID_PARAM: 267 return (ENXIO); 268 case CVMX_MGMT_PORT_INIT_ERROR: 269 return (EIO); 270 } 271 272 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_intr); 273 /* XXX Incomplete. */ 274 275 return (0); 276} 277 278static int 279octm_shutdown(device_t dev) 280{ 281 return (octm_detach(dev)); 282} 283 284static void 285octm_init(void *arg) 286{ 287 struct ifnet *ifp; 288 struct octm_softc *sc; 289 cvmx_mgmt_port_netdevice_flags_t flags; 290 uint64_t mac; 291 292 sc = arg; 293 ifp = sc->sc_ifp; 294 295 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) { 296 cvmx_mgmt_port_disable(sc->sc_port); 297 298 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 299 } 300 301 if (((ifp->if_flags ^ sc->sc_flags) & (IFF_ALLMULTI | IFF_MULTICAST | IFF_PROMISC)) != 0) { 302 flags = 0; 303 if ((ifp->if_flags & IFF_ALLMULTI) != 0) 304 flags |= CVMX_IFF_ALLMULTI; 305 if ((ifp->if_flags & IFF_PROMISC) != 0) 306 flags |= CVMX_IFF_PROMISC; 307 cvmx_mgmt_port_set_multicast_list(sc->sc_port, flags); 308 } 309 310 mac = 0; 311 memcpy((u_int8_t *)&mac + 2, IF_LLADDR(ifp), 6); 312 cvmx_mgmt_port_set_mac(sc->sc_port, mac); 313 314 /* XXX link state? */ 315 316 if ((ifp->if_flags & IFF_UP) != 0) 317 cvmx_mgmt_port_enable(sc->sc_port); 318 319 ifp->if_drv_flags |= IFF_DRV_RUNNING; 320 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 321} 322 323static int 324octm_transmit(struct ifnet *ifp, struct mbuf *m) 325{ 326 struct octm_softc *sc; 327 cvmx_mgmt_port_result_t result; 328 329 sc = ifp->if_softc; 330 331 if ((ifp->if_drv_flags & (IFF_DRV_RUNNING | IFF_DRV_OACTIVE)) != 332 IFF_DRV_RUNNING) { 333 m_freem(m); 334 return (0); 335 } 336 337 result = cvmx_mgmt_port_sendm(sc->sc_port, m); 338 339 if (result == CVMX_MGMT_PORT_SUCCESS) { 340 ETHER_BPF_MTAP(ifp, m); 341 342 ifp->if_opackets++; 343 ifp->if_obytes += m->m_pkthdr.len; 344 } else 345 ifp->if_oerrors++; 346 347 m_freem(m); 348 349 switch (result) { 350 case CVMX_MGMT_PORT_SUCCESS: 351 return (0); 352 case CVMX_MGMT_PORT_NO_MEMORY: 353 return (ENOBUFS); 354 case CVMX_MGMT_PORT_INVALID_PARAM: 355 return (ENXIO); 356 case CVMX_MGMT_PORT_INIT_ERROR: 357 return (EIO); 358 default: 359 return (EDOOFUS); 360 } 361} 362 363static int 364octm_medchange(struct ifnet *ifp) 365{ 366 return (ENOTSUP); 367} 368 369static void 370octm_medstat(struct ifnet *ifp, struct ifmediareq *ifm) 371{ 372 struct octm_softc *sc; 373 cvmx_helper_link_info_t link_info; 374 375 sc = ifp->if_softc; 376 377 ifm->ifm_status = IFM_AVALID; 378 ifm->ifm_active = IFT_ETHER; 379 380 link_info = cvmx_mgmt_port_link_get(sc->sc_port); 381 if (!link_info.s.link_up) 382 return; 383 384 ifm->ifm_status |= IFM_ACTIVE; 385 386 switch (link_info.s.speed) { 387 case 10: 388 ifm->ifm_active |= IFM_10_T; 389 break; 390 case 100: 391 ifm->ifm_active |= IFM_100_TX; 392 break; 393 case 1000: 394 ifm->ifm_active |= IFM_1000_T; 395 break; 396 case 10000: 397 ifm->ifm_active |= IFM_10G_T; 398 break; 399 } 400 401 if (link_info.s.full_duplex) 402 ifm->ifm_active |= IFM_FDX; 403 else 404 ifm->ifm_active |= IFM_HDX; 405} 406 407static int 408octm_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 409{ 410 struct octm_softc *sc; 411 struct ifreq *ifr; 412#ifdef INET 413 struct ifaddr *ifa; 414#endif 415 int error; 416 417 sc = ifp->if_softc; 418 ifr = (struct ifreq *)data; 419#ifdef INET 420 ifa = (struct ifaddr *)data; 421#endif 422 423 switch (cmd) { 424 case SIOCSIFADDR: 425#ifdef INET 426 /* 427 * Avoid reinitialization unless it's necessary. 428 */ 429 if (ifa->ifa_addr->sa_family == AF_INET) { 430 ifp->if_flags |= IFF_UP; 431 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) 432 octm_init(sc); 433 arp_ifinit(ifp, ifa); 434 435 return (0); 436 } 437#endif 438 error = ether_ioctl(ifp, cmd, data); 439 if (error != 0) 440 return (error); 441 return (0); 442 443 case SIOCSIFFLAGS: 444 if (ifp->if_flags == sc->sc_flags) 445 return (0); 446 if ((ifp->if_flags & IFF_UP) != 0) { 447 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) 448 octm_init(sc); 449 } else { 450 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) { 451 cvmx_mgmt_port_disable(sc->sc_port); 452 453 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 454 } 455 } 456 sc->sc_flags = ifp->if_flags; 457 return (0); 458 459 case SIOCSIFCAP: 460 /* 461 * Just change the capabilities in software, currently none 462 * require reprogramming hardware, they just toggle whether we 463 * make use of already-present facilities in software. 464 */ 465 ifp->if_capenable = ifr->ifr_reqcap; 466 return (0); 467 468 case SIOCSIFMTU: 469 cvmx_mgmt_port_set_max_packet_size(sc->sc_port, ifr->ifr_mtu + ifp->if_data.ifi_hdrlen); 470 return (0); 471 472 case SIOCSIFMEDIA: 473 case SIOCGIFMEDIA: 474 error = ifmedia_ioctl(ifp, ifr, &sc->sc_ifmedia, cmd); 475 if (error != 0) 476 return (error); 477 return (0); 478 479 default: 480 error = ether_ioctl(ifp, cmd, data); 481 if (error != 0) 482 return (error); 483 return (0); 484 } 485} 486 487static void 488octm_rx_intr(void *arg) 489{ 490 struct octm_softc *sc = arg; 491 cvmx_mixx_isr_t mixx_isr; 492 int len; 493 494 mixx_isr.u64 = cvmx_read_csr(CVMX_MIXX_ISR(sc->sc_port)); 495 if (!mixx_isr.s.irthresh) { 496 device_printf(sc->sc_dev, "stray interrupt.\n"); 497 return; 498 } 499 500 for (;;) { 501 struct mbuf *m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); 502 if (m == NULL) { 503 device_printf(sc->sc_dev, "no memory for receive mbuf.\n"); 504 return; 505 } 506 507 508 len = cvmx_mgmt_port_receive(sc->sc_port, MCLBYTES, m->m_data); 509 if (len > 0) { 510 m->m_pkthdr.rcvif = sc->sc_ifp; 511 m->m_pkthdr.len = m->m_len = len; 512 513 sc->sc_ifp->if_ipackets++; 514 515 (*sc->sc_ifp->if_input)(sc->sc_ifp, m); 516 517 continue; 518 } 519 520 m_freem(m); 521 522 if (len == 0) 523 break; 524 525 sc->sc_ifp->if_ierrors++; 526 } 527 528 /* Acknowledge interrupts. */ 529 cvmx_write_csr(CVMX_MIXX_ISR(sc->sc_port), mixx_isr.u64); 530 cvmx_read_csr(CVMX_MIXX_ISR(sc->sc_port)); 531}
|