2 * Copyright (c) 2010-2016 Solarflare Communications Inc.
5 * This software was developed in part by Philip Paeps under contract for
6 * Solarflare Communications, Inc.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
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.
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.
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.
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
37 #include <sys/param.h>
38 #include <sys/condvar.h>
40 #include <sys/mutex.h>
42 #include <sys/syslog.h>
43 #include <sys/taskqueue.h>
44 #include <sys/malloc.h>
46 #include "common/efx.h"
47 #include "common/efx_mcdi.h"
48 #include "common/efx_regs_mcdi.h"
52 #if EFSYS_OPT_MCDI_LOGGING
53 #include <dev/pci/pcivar.h>
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 */
61 sfxge_mcdi_timeout(struct sfxge_softc *sc)
63 device_t dev = sc->dev;
65 log(LOG_WARNING, "[%s%d] MC_TIMEOUT", device_get_name(dev),
66 device_get_unit(dev));
68 EFSYS_PROBE(mcdi_timeout);
69 sfxge_schedule_reset(sc);
73 sfxge_mcdi_poll(struct sfxge_softc *sc)
81 delay_us = SFXGE_MCDI_POLL_INTERVAL_MIN;
85 if (efx_mcdi_request_poll(enp)) {
86 EFSYS_PROBE1(mcdi_delay, clock_t, delay_total);
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);
97 /* Spin or block depending on delay interval. */
98 if (delay_us < 1000000)
101 pause("mcdi wait", delay_us * hz / 1000000);
103 delay_total += delay_us;
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;
114 sfxge_mcdi_execute(void *arg, efx_mcdi_req_t *emrp)
116 struct sfxge_softc *sc;
117 struct sfxge_mcdi *mcdi;
119 sc = (struct sfxge_softc *)arg;
122 SFXGE_MCDI_LOCK(mcdi);
124 KASSERT(mcdi->state == SFXGE_MCDI_INITIALIZED,
125 ("MCDI not initialized"));
127 /* Issue request and poll for completion. */
128 efx_mcdi_request_start(sc->enp, emrp, B_FALSE);
131 SFXGE_MCDI_UNLOCK(mcdi);
135 sfxge_mcdi_ev_cpl(void *arg)
137 struct sfxge_softc *sc;
138 struct sfxge_mcdi *mcdi;
140 sc = (struct sfxge_softc *)arg;
143 KASSERT(mcdi->state == SFXGE_MCDI_INITIALIZED,
144 ("MCDI not initialized"));
146 /* We do not use MCDI completion, MCDI is simply polled */
150 sfxge_mcdi_exception(void *arg, efx_mcdi_exception_t eme)
152 struct sfxge_softc *sc;
155 sc = (struct sfxge_softc *)arg;
158 log(LOG_WARNING, "[%s%d] MC_%s", device_get_name(dev),
159 device_get_unit(dev),
160 (eme == EFX_MCDI_EXCEPTION_MC_REBOOT)
162 : (eme == EFX_MCDI_EXCEPTION_MC_BADASSERT)
163 ? "BADASSERT" : "UNKNOWN");
165 EFSYS_PROBE(mcdi_exception);
167 sfxge_schedule_reset(sc);
170 #if EFSYS_OPT_MCDI_LOGGING
172 #define SFXGE_MCDI_LOG_BUF_SIZE 128
175 sfxge_mcdi_do_log(char *buffer, void *data, size_t data_size,
176 size_t pfxsize, size_t position)
178 uint32_t *words = data;
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);
187 snprintf(buffer + position, SFXGE_MCDI_LOG_BUF_SIZE - position,
190 position += 2 * sizeof(uint32_t) + 1;
196 sfxge_mcdi_logger(void *arg, efx_log_msg_t type,
197 void *header, size_t header_size,
198 void *data, size_t data_size)
200 struct sfxge_softc *sc = (struct sfxge_softc *)arg;
201 char buffer[SFXGE_MCDI_LOG_BUF_SIZE];
205 if (!sc->mcdi_logging)
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,
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);
229 sfxge_mcdi_ioctl(struct sfxge_softc *sc, sfxge_ioc_t *ip)
231 const efx_nic_cfg_t *encp = efx_nic_cfg_get(sc->enp);
232 struct sfxge_mcdi *mp = &(sc->mcdi);
237 if (mp->state == SFXGE_MCDI_UNINITIALIZED) {
242 if (!(encp->enc_features & EFX_FEATURE_MCDI)) {
247 if (ip->u.mcdi.len > SFXGE_MCDI_MAX_PAYLOAD) {
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) {
257 emr.emr_cmd = ip->u.mcdi.cmd;
258 emr.emr_in_buf = mcdibuf;
259 emr.emr_in_length = ip->u.mcdi.len;
261 emr.emr_out_buf = mcdibuf;
262 emr.emr_out_length = SFXGE_MCDI_MAX_PAYLOAD;
264 sfxge_mcdi_execute(sc, &emr);
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) {
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
277 if (ip->u.mcdi.cmd == MC_CMD_REBOOT) {
279 EFSYS_PROBE(mcdi_ioctl_mc_reboot);
280 /* sfxge_t->s_state_lock held */
281 (void) sfxge_schedule_reset(sc);
284 free(mcdibuf, M_TEMP);
290 free(mcdibuf, M_TEMP);
299 sfxge_mcdi_init(struct sfxge_softc *sc)
302 struct sfxge_mcdi *mcdi;
303 efx_mcdi_transport_t *emtp;
310 emtp = &mcdi->transport;
312 max_msg_size = sizeof (uint32_t) + MCDI_CTL_SDU_LEN_MAX_V2;
314 KASSERT(mcdi->state == SFXGE_MCDI_UNINITIALIZED,
315 ("MCDI already initialized"));
317 SFXGE_MCDI_LOCK_INIT(mcdi, device_get_nameunit(sc->dev));
319 mcdi->state = SFXGE_MCDI_INITIALIZED;
321 if ((rc = sfxge_dma_alloc(sc, max_msg_size, esmp)) != 0)
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,
338 if ((rc = efx_mcdi_init(enp, emtp)) != 0)
344 SFXGE_MCDI_LOCK_DESTROY(mcdi);
345 mcdi->state = SFXGE_MCDI_UNINITIALIZED;
350 sfxge_mcdi_fini(struct sfxge_softc *sc)
352 struct sfxge_mcdi *mcdi;
354 efx_mcdi_transport_t *emtp;
359 emtp = &mcdi->transport;
362 SFXGE_MCDI_LOCK(mcdi);
363 KASSERT(mcdi->state == SFXGE_MCDI_INITIALIZED,
364 ("MCDI not initialized"));
367 bzero(emtp, sizeof(*emtp));
369 SFXGE_MCDI_UNLOCK(mcdi);
371 sfxge_dma_free(esmp);
373 SFXGE_MCDI_LOCK_DESTROY(mcdi);