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