sfxge_mcdi.c revision 302408
1/*- 2 * Copyright (c) 2010-2016 Solarflare Communications Inc. 3 * All rights reserved. 4 * 5 * This software was developed in part by Philip Paeps under contract for 6 * Solarflare Communications, Inc. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright notice, 12 * this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright notice, 14 * this list of conditions and the following disclaimer in the documentation 15 * and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 18 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 19 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 20 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 21 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 22 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 23 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 24 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 25 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 26 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 27 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 * 29 * The views and conclusions contained in the software and documentation are 30 * those of the authors and should not be interpreted as representing official 31 * policies, either expressed or implied, of the FreeBSD Project. 32 */ 33 34#include <sys/cdefs.h> 35__FBSDID("$FreeBSD: stable/11/sys/dev/sfxge/sfxge_mcdi.c 300607 2016-05-24 12:16:57Z arybchik $"); 36 37#include <sys/param.h> 38#include <sys/condvar.h> 39#include <sys/lock.h> 40#include <sys/mutex.h> 41#include <sys/proc.h> 42#include <sys/syslog.h> 43#include <sys/taskqueue.h> 44#include <sys/malloc.h> 45 46#include "common/efx.h" 47#include "common/efx_mcdi.h" 48#include "common/efx_regs_mcdi.h" 49 50#include "sfxge.h" 51 52#if EFSYS_OPT_MCDI_LOGGING 53#include <dev/pci/pcivar.h> 54#endif 55 56#define SFXGE_MCDI_POLL_INTERVAL_MIN 10 /* 10us in 1us units */ 57#define SFXGE_MCDI_POLL_INTERVAL_MAX 100000 /* 100ms in 1us units */ 58#define SFXGE_MCDI_WATCHDOG_INTERVAL 10000000 /* 10s in 1us units */ 59 60static void 61sfxge_mcdi_timeout(struct sfxge_softc *sc) 62{ 63 device_t dev = sc->dev; 64 65 log(LOG_WARNING, "[%s%d] MC_TIMEOUT", device_get_name(dev), 66 device_get_unit(dev)); 67 68 EFSYS_PROBE(mcdi_timeout); 69 sfxge_schedule_reset(sc); 70} 71 72static void 73sfxge_mcdi_poll(struct sfxge_softc *sc) 74{ 75 efx_nic_t *enp; 76 clock_t delay_total; 77 clock_t delay_us; 78 boolean_t aborted; 79 80 delay_total = 0; 81 delay_us = SFXGE_MCDI_POLL_INTERVAL_MIN; 82 enp = sc->enp; 83 84 do { 85 if (efx_mcdi_request_poll(enp)) { 86 EFSYS_PROBE1(mcdi_delay, clock_t, delay_total); 87 return; 88 } 89 90 if (delay_total > SFXGE_MCDI_WATCHDOG_INTERVAL) { 91 aborted = efx_mcdi_request_abort(enp); 92 KASSERT(aborted, ("abort failed")); 93 sfxge_mcdi_timeout(sc); 94 return; 95 } 96 97 /* Spin or block depending on delay interval. */ 98 if (delay_us < 1000000) 99 DELAY(delay_us); 100 else 101 pause("mcdi wait", delay_us * hz / 1000000); 102 103 delay_total += delay_us; 104 105 /* Exponentially back off the poll frequency. */ 106 delay_us = delay_us * 2; 107 if (delay_us > SFXGE_MCDI_POLL_INTERVAL_MAX) 108 delay_us = SFXGE_MCDI_POLL_INTERVAL_MAX; 109 110 } while (1); 111} 112 113static void 114sfxge_mcdi_execute(void *arg, efx_mcdi_req_t *emrp) 115{ 116 struct sfxge_softc *sc; 117 struct sfxge_mcdi *mcdi; 118 119 sc = (struct sfxge_softc *)arg; 120 mcdi = &sc->mcdi; 121 122 SFXGE_MCDI_LOCK(mcdi); 123 124 KASSERT(mcdi->state == SFXGE_MCDI_INITIALIZED, 125 ("MCDI not initialized")); 126 127 /* Issue request and poll for completion. */ 128 efx_mcdi_request_start(sc->enp, emrp, B_FALSE); 129 sfxge_mcdi_poll(sc); 130 131 SFXGE_MCDI_UNLOCK(mcdi); 132} 133 134static void 135sfxge_mcdi_ev_cpl(void *arg) 136{ 137 struct sfxge_softc *sc; 138 struct sfxge_mcdi *mcdi; 139 140 sc = (struct sfxge_softc *)arg; 141 mcdi = &sc->mcdi; 142 143 KASSERT(mcdi->state == SFXGE_MCDI_INITIALIZED, 144 ("MCDI not initialized")); 145 146 /* We do not use MCDI completion, MCDI is simply polled */ 147} 148 149static void 150sfxge_mcdi_exception(void *arg, efx_mcdi_exception_t eme) 151{ 152 struct sfxge_softc *sc; 153 device_t dev; 154 155 sc = (struct sfxge_softc *)arg; 156 dev = sc->dev; 157 158 log(LOG_WARNING, "[%s%d] MC_%s", device_get_name(dev), 159 device_get_unit(dev), 160 (eme == EFX_MCDI_EXCEPTION_MC_REBOOT) 161 ? "REBOOT" 162 : (eme == EFX_MCDI_EXCEPTION_MC_BADASSERT) 163 ? "BADASSERT" : "UNKNOWN"); 164 165 EFSYS_PROBE(mcdi_exception); 166 167 sfxge_schedule_reset(sc); 168} 169 170#if EFSYS_OPT_MCDI_LOGGING 171 172#define SFXGE_MCDI_LOG_BUF_SIZE 128 173 174static size_t 175sfxge_mcdi_do_log(char *buffer, void *data, size_t data_size, 176 size_t pfxsize, size_t position) 177{ 178 uint32_t *words = data; 179 size_t i; 180 181 for (i = 0; i < data_size; i += sizeof(*words)) { 182 if (position + 2 * sizeof(*words) + 1 >= SFXGE_MCDI_LOG_BUF_SIZE) { 183 buffer[position] = '\0'; 184 printf("%s \\\n", buffer); 185 position = pfxsize; 186 } 187 snprintf(buffer + position, SFXGE_MCDI_LOG_BUF_SIZE - position, 188 " %08x", *words); 189 words++; 190 position += 2 * sizeof(uint32_t) + 1; 191 } 192 return (position); 193} 194 195static void 196sfxge_mcdi_logger(void *arg, efx_log_msg_t type, 197 void *header, size_t header_size, 198 void *data, size_t data_size) 199{ 200 struct sfxge_softc *sc = (struct sfxge_softc *)arg; 201 char buffer[SFXGE_MCDI_LOG_BUF_SIZE]; 202 size_t pfxsize; 203 size_t start; 204 205 if (!sc->mcdi_logging) 206 return; 207 208 pfxsize = snprintf(buffer, sizeof(buffer), 209 "sfc %04x:%02x:%02x.%02x %s MCDI RPC %s:", 210 pci_get_domain(sc->dev), 211 pci_get_bus(sc->dev), 212 pci_get_slot(sc->dev), 213 pci_get_function(sc->dev), 214 device_get_nameunit(sc->dev), 215 type == EFX_LOG_MCDI_REQUEST ? "REQ" : 216 type == EFX_LOG_MCDI_RESPONSE ? "RESP" : "???"); 217 start = sfxge_mcdi_do_log(buffer, header, header_size, 218 pfxsize, pfxsize); 219 start = sfxge_mcdi_do_log(buffer, data, data_size, pfxsize, start); 220 if (start != pfxsize) { 221 buffer[start] = '\0'; 222 printf("%s\n", buffer); 223 } 224} 225 226#endif 227 228int 229sfxge_mcdi_ioctl(struct sfxge_softc *sc, sfxge_ioc_t *ip) 230{ 231 const efx_nic_cfg_t *encp = efx_nic_cfg_get(sc->enp); 232 struct sfxge_mcdi *mp = &(sc->mcdi); 233 efx_mcdi_req_t emr; 234 uint8_t *mcdibuf; 235 int rc; 236 237 if (mp->state == SFXGE_MCDI_UNINITIALIZED) { 238 rc = ENODEV; 239 goto fail1; 240 } 241 242 if (!(encp->enc_features & EFX_FEATURE_MCDI)) { 243 rc = ENOTSUP; 244 goto fail2; 245 } 246 247 if (ip->u.mcdi.len > SFXGE_MCDI_MAX_PAYLOAD) { 248 rc = EINVAL; 249 goto fail3; 250 } 251 252 mcdibuf = malloc(SFXGE_MCDI_MAX_PAYLOAD, M_TEMP, M_WAITOK | M_ZERO); 253 if ((rc = copyin(ip->u.mcdi.payload, mcdibuf, ip->u.mcdi.len)) != 0) { 254 goto fail5; 255 } 256 257 emr.emr_cmd = ip->u.mcdi.cmd; 258 emr.emr_in_buf = mcdibuf; 259 emr.emr_in_length = ip->u.mcdi.len; 260 261 emr.emr_out_buf = mcdibuf; 262 emr.emr_out_length = SFXGE_MCDI_MAX_PAYLOAD; 263 264 sfxge_mcdi_execute(sc, &emr); 265 266 ip->u.mcdi.rc = emr.emr_rc; 267 ip->u.mcdi.cmd = emr.emr_cmd; 268 ip->u.mcdi.len = emr.emr_out_length_used; 269 if ((rc = copyout(mcdibuf, ip->u.mcdi.payload, ip->u.mcdi.len)) != 0) { 270 goto fail6; 271 } 272 273 /* 274 * Helpfully trigger a device reset in response to an MCDI_CMD_REBOOT 275 * Both ports will see ->emt_exception callbacks on the next MCDI poll 276 */ 277 if (ip->u.mcdi.cmd == MC_CMD_REBOOT) { 278 279 EFSYS_PROBE(mcdi_ioctl_mc_reboot); 280 /* sfxge_t->s_state_lock held */ 281 (void) sfxge_schedule_reset(sc); 282 } 283 284 free(mcdibuf, M_TEMP); 285 286 return (0); 287 288fail6: 289fail5: 290 free(mcdibuf, M_TEMP); 291fail3: 292fail2: 293fail1: 294 return (rc); 295} 296 297 298int 299sfxge_mcdi_init(struct sfxge_softc *sc) 300{ 301 efx_nic_t *enp; 302 struct sfxge_mcdi *mcdi; 303 efx_mcdi_transport_t *emtp; 304 efsys_mem_t *esmp; 305 int max_msg_size; 306 int rc; 307 308 enp = sc->enp; 309 mcdi = &sc->mcdi; 310 emtp = &mcdi->transport; 311 esmp = &mcdi->mem; 312 max_msg_size = sizeof (uint32_t) + MCDI_CTL_SDU_LEN_MAX_V2; 313 314 KASSERT(mcdi->state == SFXGE_MCDI_UNINITIALIZED, 315 ("MCDI already initialized")); 316 317 SFXGE_MCDI_LOCK_INIT(mcdi, device_get_nameunit(sc->dev)); 318 319 mcdi->state = SFXGE_MCDI_INITIALIZED; 320 321 if ((rc = sfxge_dma_alloc(sc, max_msg_size, esmp)) != 0) 322 goto fail; 323 324 emtp->emt_context = sc; 325 emtp->emt_dma_mem = esmp; 326 emtp->emt_execute = sfxge_mcdi_execute; 327 emtp->emt_ev_cpl = sfxge_mcdi_ev_cpl; 328 emtp->emt_exception = sfxge_mcdi_exception; 329#if EFSYS_OPT_MCDI_LOGGING 330 emtp->emt_logger = sfxge_mcdi_logger; 331 SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->dev), 332 SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)), 333 OID_AUTO, "mcdi_logging", CTLFLAG_RW, 334 &sc->mcdi_logging, 0, 335 "MCDI logging"); 336#endif 337 338 if ((rc = efx_mcdi_init(enp, emtp)) != 0) 339 goto fail; 340 341 return (0); 342 343fail: 344 SFXGE_MCDI_LOCK_DESTROY(mcdi); 345 mcdi->state = SFXGE_MCDI_UNINITIALIZED; 346 return (rc); 347} 348 349void 350sfxge_mcdi_fini(struct sfxge_softc *sc) 351{ 352 struct sfxge_mcdi *mcdi; 353 efx_nic_t *enp; 354 efx_mcdi_transport_t *emtp; 355 efsys_mem_t *esmp; 356 357 enp = sc->enp; 358 mcdi = &sc->mcdi; 359 emtp = &mcdi->transport; 360 esmp = &mcdi->mem; 361 362 SFXGE_MCDI_LOCK(mcdi); 363 KASSERT(mcdi->state == SFXGE_MCDI_INITIALIZED, 364 ("MCDI not initialized")); 365 366 efx_mcdi_fini(enp); 367 bzero(emtp, sizeof(*emtp)); 368 369 SFXGE_MCDI_UNLOCK(mcdi); 370 371 sfxge_dma_free(esmp); 372 373 SFXGE_MCDI_LOCK_DESTROY(mcdi); 374} 375