1272343Sngie/*- 2272343Sngie * Copyright (c) 2010-2015 Solarflare Communications Inc. 3272343Sngie * All rights reserved. 4272343Sngie * 5272343Sngie * This software was developed in part by Philip Paeps under contract for 6272343Sngie * Solarflare Communications, Inc. 7272343Sngie * 8272343Sngie * Redistribution and use in source and binary forms, with or without 9272343Sngie * modification, are permitted provided that the following conditions are met: 10272343Sngie * 11272343Sngie * 1. Redistributions of source code must retain the above copyright notice, 12272343Sngie * this list of conditions and the following disclaimer. 13272343Sngie * 2. Redistributions in binary form must reproduce the above copyright notice, 14272343Sngie * this list of conditions and the following disclaimer in the documentation 15272343Sngie * and/or other materials provided with the distribution. 16272343Sngie * 17272343Sngie * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 18272343Sngie * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 19272343Sngie * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 20272343Sngie * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 21272343Sngie * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 22272343Sngie * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 23272343Sngie * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 24272343Sngie * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 25272343Sngie * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 26272343Sngie * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 27272343Sngie * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28272343Sngie * 29272343Sngie * The views and conclusions contained in the software and documentation are 30272343Sngie * those of the authors and should not be interpreted as representing official 31272343Sngie * policies, either expressed or implied, of the FreeBSD Project. 32272343Sngie */ 33272343Sngie 34272343Sngie#include <sys/cdefs.h> 35272343Sngie__FBSDID("$FreeBSD: releng/10.3/sys/dev/sfxge/sfxge_mcdi.c 293946 2016-01-14 15:07:02Z arybchik $"); 36272343Sngie 37272343Sngie#include <sys/param.h> 38272343Sngie#include <sys/condvar.h> 39272343Sngie#include <sys/lock.h> 40272343Sngie#include <sys/mutex.h> 41272343Sngie#include <sys/proc.h> 42272343Sngie#include <sys/syslog.h> 43272343Sngie#include <sys/taskqueue.h> 44272343Sngie#include <sys/malloc.h> 45272343Sngie 46272343Sngie#include "common/efx.h" 47272343Sngie#include "common/efx_mcdi.h" 48272343Sngie#include "common/efx_regs_mcdi.h" 49272343Sngie 50272343Sngie#include "sfxge.h" 51272343Sngie 52272343Sngie#if EFSYS_OPT_MCDI_LOGGING 53272343Sngie#include <dev/pci/pcivar.h> 54272343Sngie#endif 55272343Sngie 56272343Sngie#define SFXGE_MCDI_POLL_INTERVAL_MIN 10 /* 10us in 1us units */ 57272343Sngie#define SFXGE_MCDI_POLL_INTERVAL_MAX 100000 /* 100ms in 1us units */ 58272343Sngie#define SFXGE_MCDI_WATCHDOG_INTERVAL 10000000 /* 10s in 1us units */ 59272343Sngie 60272343Sngiestatic void 61272343Sngiesfxge_mcdi_timeout(struct sfxge_softc *sc) 62272343Sngie{ 63272343Sngie 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 (mcdibuf == NULL) { 254 rc = ENOMEM; 255 goto fail4; 256 } 257 if ((rc = copyin(ip->u.mcdi.payload, mcdibuf, ip->u.mcdi.len)) != 0) { 258 goto fail5; 259 } 260 261 emr.emr_cmd = ip->u.mcdi.cmd; 262 emr.emr_in_buf = mcdibuf; 263 emr.emr_in_length = ip->u.mcdi.len; 264 265 emr.emr_out_buf = mcdibuf; 266 emr.emr_out_length = SFXGE_MCDI_MAX_PAYLOAD; 267 268 sfxge_mcdi_execute(sc, &emr); 269 270 ip->u.mcdi.rc = emr.emr_rc; 271 ip->u.mcdi.cmd = emr.emr_cmd; 272 ip->u.mcdi.len = emr.emr_out_length_used; 273 if ((rc = copyout(mcdibuf, ip->u.mcdi.payload, ip->u.mcdi.len)) != 0) { 274 goto fail6; 275 } 276 277 /* 278 * Helpfully trigger a device reset in response to an MCDI_CMD_REBOOT 279 * Both ports will see ->emt_exception callbacks on the next MCDI poll 280 */ 281 if (ip->u.mcdi.cmd == MC_CMD_REBOOT) { 282 283 EFSYS_PROBE(mcdi_ioctl_mc_reboot); 284 /* sfxge_t->s_state_lock held */ 285 (void) sfxge_schedule_reset(sc); 286 } 287 288 free(mcdibuf, M_TEMP); 289 290 return (0); 291 292fail6: 293fail5: 294 free(mcdibuf, M_TEMP); 295fail4: 296fail3: 297fail2: 298fail1: 299 return (rc); 300} 301 302 303int 304sfxge_mcdi_init(struct sfxge_softc *sc) 305{ 306 efx_nic_t *enp; 307 struct sfxge_mcdi *mcdi; 308 efx_mcdi_transport_t *emtp; 309 efsys_mem_t *esmp; 310 int max_msg_size; 311 int rc; 312 313 enp = sc->enp; 314 mcdi = &sc->mcdi; 315 emtp = &mcdi->transport; 316 esmp = &mcdi->mem; 317 max_msg_size = sizeof (uint32_t) + MCDI_CTL_SDU_LEN_MAX_V2; 318 319 KASSERT(mcdi->state == SFXGE_MCDI_UNINITIALIZED, 320 ("MCDI already initialized")); 321 322 SFXGE_MCDI_LOCK_INIT(mcdi, device_get_nameunit(sc->dev)); 323 324 mcdi->state = SFXGE_MCDI_INITIALIZED; 325 326 if ((rc = sfxge_dma_alloc(sc, max_msg_size, esmp)) != 0) 327 goto fail; 328 329 emtp->emt_context = sc; 330 emtp->emt_dma_mem = esmp; 331 emtp->emt_execute = sfxge_mcdi_execute; 332 emtp->emt_ev_cpl = sfxge_mcdi_ev_cpl; 333 emtp->emt_exception = sfxge_mcdi_exception; 334#if EFSYS_OPT_MCDI_LOGGING 335 emtp->emt_logger = sfxge_mcdi_logger; 336 SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->dev), 337 SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)), 338 OID_AUTO, "mcdi_logging", CTLFLAG_RW, 339 &sc->mcdi_logging, 0, 340 "MCDI logging"); 341#endif 342 343 if ((rc = efx_mcdi_init(enp, emtp)) != 0) 344 goto fail; 345 346 return (0); 347 348fail: 349 SFXGE_MCDI_LOCK_DESTROY(mcdi); 350 mcdi->state = SFXGE_MCDI_UNINITIALIZED; 351 return (rc); 352} 353 354void 355sfxge_mcdi_fini(struct sfxge_softc *sc) 356{ 357 struct sfxge_mcdi *mcdi; 358 efx_nic_t *enp; 359 efx_mcdi_transport_t *emtp; 360 efsys_mem_t *esmp; 361 362 enp = sc->enp; 363 mcdi = &sc->mcdi; 364 emtp = &mcdi->transport; 365 esmp = &mcdi->mem; 366 367 SFXGE_MCDI_LOCK(mcdi); 368 KASSERT(mcdi->state == SFXGE_MCDI_INITIALIZED, 369 ("MCDI not initialized")); 370 371 efx_mcdi_fini(enp); 372 bzero(emtp, sizeof(*emtp)); 373 374 SFXGE_MCDI_UNLOCK(mcdi); 375 376 sfxge_dma_free(esmp); 377 378 SFXGE_MCDI_LOCK_DESTROY(mcdi); 379} 380