1/*-
2 * Copyright (c) 2012-2015 Solarflare Communications Inc.
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 are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
21 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
24 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 *
26 * The views and conclusions contained in the software and documentation are
27 * those of the authors and should not be interpreted as representing official
28 * policies, either expressed or implied, of the FreeBSD Project.
29 */
30
31#include <sys/cdefs.h>
| 1/*-
2 * Copyright (c) 2012-2015 Solarflare Communications Inc.
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 are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
21 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
24 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 *
26 * The views and conclusions contained in the software and documentation are
27 * those of the authors and should not be interpreted as representing official
28 * policies, either expressed or implied, of the FreeBSD Project.
29 */
30
31#include <sys/cdefs.h>
|
32__FBSDID("$FreeBSD: head/sys/dev/sfxge/common/hunt_mcdi.c 291928 2015-12-07 07:22:21Z arybchik $");
| 32__FBSDID("$FreeBSD: head/sys/dev/sfxge/common/hunt_mcdi.c 291985 2015-12-08 06:25:52Z arybchik $");
|
33
34#include "efsys.h"
35#include "efx.h"
36#include "efx_impl.h"
37
38
39#if EFSYS_OPT_HUNTINGTON
40
41#if EFSYS_OPT_MCDI
42
43#ifndef WITH_MCDI_V2
44#error "WITH_MCDI_V2 required for Huntington MCDIv2 commands."
45#endif
46
47typedef enum efx_mcdi_header_type_e {
48 EFX_MCDI_HEADER_TYPE_V1, /* MCDIv0 (BootROM), MCDIv1 commands */
49 EFX_MCDI_HEADER_TYPE_V2, /* MCDIv2 commands */
50} efx_mcdi_header_type_t;
51
52/*
53 * Return the header format to use for sending an MCDI request.
54 *
55 * An MCDIv1 (Siena compatible) command should use MCDIv2 encapsulation if the
56 * request input buffer or response output buffer are too large for the MCDIv1
57 * format. An MCDIv2 command must always be sent using MCDIv2 encapsulation.
58 */
59#define EFX_MCDI_HEADER_TYPE(_cmd, _length) \
60 ((((_cmd) & ~EFX_MASK32(MCDI_HEADER_CODE)) || \
61 ((_length) & ~EFX_MASK32(MCDI_HEADER_DATALEN))) ? \
62 EFX_MCDI_HEADER_TYPE_V2 : EFX_MCDI_HEADER_TYPE_V1)
63
64
65/*
66 * MCDI Header NOT_EPOCH flag
67 * ==========================
68 * A new epoch begins at initial startup or after an MC reboot, and defines when
69 * the MC should reject stale MCDI requests.
70 *
71 * The first MCDI request sent by the host should contain NOT_EPOCH=0, and all
72 * subsequent requests (until the next MC reboot) should contain NOT_EPOCH=1.
73 *
74 * After rebooting the MC will fail all requests with NOT_EPOCH=1 by writing a
75 * response with ERROR=1 and DATALEN=0 until a request is seen with NOT_EPOCH=0.
76 */
77
78
79 __checkReturn efx_rc_t
80hunt_mcdi_init(
81 __in efx_nic_t *enp,
82 __in const efx_mcdi_transport_t *emtp)
83{
84 efsys_mem_t *esmp = emtp->emt_dma_mem;
85 efx_dword_t dword;
86 efx_rc_t rc;
87
88 EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON);
89 EFSYS_ASSERT(enp->en_features & EFX_FEATURE_MCDI_DMA);
90
91 /* A host DMA buffer is required for Huntington MCDI */
92 if (esmp == NULL) {
93 rc = EINVAL;
94 goto fail1;
95 }
96
97 /*
98 * Ensure that the MC doorbell is in a known state before issuing MCDI
99 * commands. The recovery algorithm requires that the MC command buffer
100 * must be 256 byte aligned. See bug24769.
101 */
102 if ((EFSYS_MEM_ADDR(esmp) & 0xFF) != 0) {
103 rc = EINVAL;
104 goto fail2;
105 }
106 EFX_POPULATE_DWORD_1(dword, EFX_DWORD_0, 1);
107 EFX_BAR_WRITED(enp, ER_DZ_MC_DB_HWRD_REG, &dword, B_FALSE);
108
109 /* Save initial MC reboot status */
110 (void) hunt_mcdi_poll_reboot(enp);
111
112 /* Start a new epoch (allow fresh MCDI requests to succeed) */
113 efx_mcdi_new_epoch(enp);
114
115 return (0);
116
117fail2:
118 EFSYS_PROBE(fail2);
119fail1:
120 EFSYS_PROBE1(fail1, efx_rc_t, rc);
121
122 return (rc);
123}
124
125 void
126hunt_mcdi_fini(
127 __in efx_nic_t *enp)
128{
129 efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
130
131 emip->emi_new_epoch = B_FALSE;
132}
133
134 void
135hunt_mcdi_request_copyin(
136 __in efx_nic_t *enp,
137 __in efx_mcdi_req_t *emrp,
138 __in unsigned int seq,
139 __in boolean_t ev_cpl,
140 __in boolean_t new_epoch)
141{
142 const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
143 efsys_mem_t *esmp = emtp->emt_dma_mem;
144 efx_mcdi_header_type_t hdr_type;
145 efx_dword_t dword;
146 efx_dword_t hdr[2];
147 unsigned int xflags;
148 unsigned int pos;
149 size_t offset;
150
151 EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
152
153 xflags = 0;
154 if (ev_cpl)
155 xflags |= MCDI_HEADER_XFLAGS_EVREQ;
156
157 offset = 0;
158
159 hdr_type = EFX_MCDI_HEADER_TYPE(emrp->emr_cmd,
160 MAX(emrp->emr_in_length, emrp->emr_out_length));
161
162 if (hdr_type == EFX_MCDI_HEADER_TYPE_V2) {
163 /* Construct MCDI v2 header */
164 EFX_POPULATE_DWORD_8(hdr[0],
165 MCDI_HEADER_CODE, MC_CMD_V2_EXTN,
166 MCDI_HEADER_RESYNC, 1,
167 MCDI_HEADER_DATALEN, 0,
168 MCDI_HEADER_SEQ, seq,
169 MCDI_HEADER_NOT_EPOCH, new_epoch ? 0 : 1,
170 MCDI_HEADER_ERROR, 0,
171 MCDI_HEADER_RESPONSE, 0,
172 MCDI_HEADER_XFLAGS, xflags);
173 EFSYS_MEM_WRITED(esmp, offset, &hdr[0]);
174 offset += sizeof (efx_dword_t);
175
176 EFX_POPULATE_DWORD_2(hdr[1],
177 MC_CMD_V2_EXTN_IN_EXTENDED_CMD, emrp->emr_cmd,
178 MC_CMD_V2_EXTN_IN_ACTUAL_LEN, emrp->emr_in_length);
179 EFSYS_MEM_WRITED(esmp, offset, &hdr[1]);
180 offset += sizeof (efx_dword_t);
181 } else {
182 /* Construct MCDI v1 header */
183 EFX_POPULATE_DWORD_8(hdr[0],
184 MCDI_HEADER_CODE, emrp->emr_cmd,
185 MCDI_HEADER_RESYNC, 1,
186 MCDI_HEADER_DATALEN, emrp->emr_in_length,
187 MCDI_HEADER_SEQ, seq,
188 MCDI_HEADER_NOT_EPOCH, new_epoch ? 0 : 1,
189 MCDI_HEADER_ERROR, 0,
190 MCDI_HEADER_RESPONSE, 0,
191 MCDI_HEADER_XFLAGS, xflags);
192 EFSYS_MEM_WRITED(esmp, 0, &hdr[0]);
193 offset += sizeof (efx_dword_t);
194 }
195
196#if EFSYS_OPT_MCDI_LOGGING
197 if (emtp->emt_logger != NULL) {
198 emtp->emt_logger(emtp->emt_context, EFX_LOG_MCDI_REQUEST,
199 &hdr, offset,
200 emrp->emr_in_buf, emrp->emr_in_length);
201 }
202#endif /* EFSYS_OPT_MCDI_LOGGING */
203
204 /* Construct the payload */
205 for (pos = 0; pos < emrp->emr_in_length; pos += sizeof (efx_dword_t)) {
206 memcpy(&dword, MCDI_IN(*emrp, efx_dword_t, pos),
207 MIN(sizeof (dword), emrp->emr_in_length - pos));
208 EFSYS_MEM_WRITED(esmp, offset + pos, &dword);
209 }
210
211 /* Ring the doorbell to post the command DMA address to the MC */
212 EFSYS_ASSERT((EFSYS_MEM_ADDR(esmp) & 0xFF) == 0);
213
214 /* Guarantee ordering of memory (MCDI request) and PIO (MC doorbell) */
215 EFSYS_DMA_SYNC_FOR_DEVICE(esmp, 0, offset + emrp->emr_in_length);
216 EFSYS_PIO_WRITE_BARRIER();
217
218 EFX_POPULATE_DWORD_1(dword,
219 EFX_DWORD_0, EFSYS_MEM_ADDR(esmp) >> 32);
220 EFX_BAR_WRITED(enp, ER_DZ_MC_DB_LWRD_REG, &dword, B_FALSE);
221
222 EFX_POPULATE_DWORD_1(dword,
223 EFX_DWORD_0, EFSYS_MEM_ADDR(esmp) & 0xffffffff);
224 EFX_BAR_WRITED(enp, ER_DZ_MC_DB_HWRD_REG, &dword, B_FALSE);
225}
226
227 void
228hunt_mcdi_request_copyout(
229 __in efx_nic_t *enp,
230 __in efx_mcdi_req_t *emrp)
231{
| 33
34#include "efsys.h"
35#include "efx.h"
36#include "efx_impl.h"
37
38
39#if EFSYS_OPT_HUNTINGTON
40
41#if EFSYS_OPT_MCDI
42
43#ifndef WITH_MCDI_V2
44#error "WITH_MCDI_V2 required for Huntington MCDIv2 commands."
45#endif
46
47typedef enum efx_mcdi_header_type_e {
48 EFX_MCDI_HEADER_TYPE_V1, /* MCDIv0 (BootROM), MCDIv1 commands */
49 EFX_MCDI_HEADER_TYPE_V2, /* MCDIv2 commands */
50} efx_mcdi_header_type_t;
51
52/*
53 * Return the header format to use for sending an MCDI request.
54 *
55 * An MCDIv1 (Siena compatible) command should use MCDIv2 encapsulation if the
56 * request input buffer or response output buffer are too large for the MCDIv1
57 * format. An MCDIv2 command must always be sent using MCDIv2 encapsulation.
58 */
59#define EFX_MCDI_HEADER_TYPE(_cmd, _length) \
60 ((((_cmd) & ~EFX_MASK32(MCDI_HEADER_CODE)) || \
61 ((_length) & ~EFX_MASK32(MCDI_HEADER_DATALEN))) ? \
62 EFX_MCDI_HEADER_TYPE_V2 : EFX_MCDI_HEADER_TYPE_V1)
63
64
65/*
66 * MCDI Header NOT_EPOCH flag
67 * ==========================
68 * A new epoch begins at initial startup or after an MC reboot, and defines when
69 * the MC should reject stale MCDI requests.
70 *
71 * The first MCDI request sent by the host should contain NOT_EPOCH=0, and all
72 * subsequent requests (until the next MC reboot) should contain NOT_EPOCH=1.
73 *
74 * After rebooting the MC will fail all requests with NOT_EPOCH=1 by writing a
75 * response with ERROR=1 and DATALEN=0 until a request is seen with NOT_EPOCH=0.
76 */
77
78
79 __checkReturn efx_rc_t
80hunt_mcdi_init(
81 __in efx_nic_t *enp,
82 __in const efx_mcdi_transport_t *emtp)
83{
84 efsys_mem_t *esmp = emtp->emt_dma_mem;
85 efx_dword_t dword;
86 efx_rc_t rc;
87
88 EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON);
89 EFSYS_ASSERT(enp->en_features & EFX_FEATURE_MCDI_DMA);
90
91 /* A host DMA buffer is required for Huntington MCDI */
92 if (esmp == NULL) {
93 rc = EINVAL;
94 goto fail1;
95 }
96
97 /*
98 * Ensure that the MC doorbell is in a known state before issuing MCDI
99 * commands. The recovery algorithm requires that the MC command buffer
100 * must be 256 byte aligned. See bug24769.
101 */
102 if ((EFSYS_MEM_ADDR(esmp) & 0xFF) != 0) {
103 rc = EINVAL;
104 goto fail2;
105 }
106 EFX_POPULATE_DWORD_1(dword, EFX_DWORD_0, 1);
107 EFX_BAR_WRITED(enp, ER_DZ_MC_DB_HWRD_REG, &dword, B_FALSE);
108
109 /* Save initial MC reboot status */
110 (void) hunt_mcdi_poll_reboot(enp);
111
112 /* Start a new epoch (allow fresh MCDI requests to succeed) */
113 efx_mcdi_new_epoch(enp);
114
115 return (0);
116
117fail2:
118 EFSYS_PROBE(fail2);
119fail1:
120 EFSYS_PROBE1(fail1, efx_rc_t, rc);
121
122 return (rc);
123}
124
125 void
126hunt_mcdi_fini(
127 __in efx_nic_t *enp)
128{
129 efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
130
131 emip->emi_new_epoch = B_FALSE;
132}
133
134 void
135hunt_mcdi_request_copyin(
136 __in efx_nic_t *enp,
137 __in efx_mcdi_req_t *emrp,
138 __in unsigned int seq,
139 __in boolean_t ev_cpl,
140 __in boolean_t new_epoch)
141{
142 const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
143 efsys_mem_t *esmp = emtp->emt_dma_mem;
144 efx_mcdi_header_type_t hdr_type;
145 efx_dword_t dword;
146 efx_dword_t hdr[2];
147 unsigned int xflags;
148 unsigned int pos;
149 size_t offset;
150
151 EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
152
153 xflags = 0;
154 if (ev_cpl)
155 xflags |= MCDI_HEADER_XFLAGS_EVREQ;
156
157 offset = 0;
158
159 hdr_type = EFX_MCDI_HEADER_TYPE(emrp->emr_cmd,
160 MAX(emrp->emr_in_length, emrp->emr_out_length));
161
162 if (hdr_type == EFX_MCDI_HEADER_TYPE_V2) {
163 /* Construct MCDI v2 header */
164 EFX_POPULATE_DWORD_8(hdr[0],
165 MCDI_HEADER_CODE, MC_CMD_V2_EXTN,
166 MCDI_HEADER_RESYNC, 1,
167 MCDI_HEADER_DATALEN, 0,
168 MCDI_HEADER_SEQ, seq,
169 MCDI_HEADER_NOT_EPOCH, new_epoch ? 0 : 1,
170 MCDI_HEADER_ERROR, 0,
171 MCDI_HEADER_RESPONSE, 0,
172 MCDI_HEADER_XFLAGS, xflags);
173 EFSYS_MEM_WRITED(esmp, offset, &hdr[0]);
174 offset += sizeof (efx_dword_t);
175
176 EFX_POPULATE_DWORD_2(hdr[1],
177 MC_CMD_V2_EXTN_IN_EXTENDED_CMD, emrp->emr_cmd,
178 MC_CMD_V2_EXTN_IN_ACTUAL_LEN, emrp->emr_in_length);
179 EFSYS_MEM_WRITED(esmp, offset, &hdr[1]);
180 offset += sizeof (efx_dword_t);
181 } else {
182 /* Construct MCDI v1 header */
183 EFX_POPULATE_DWORD_8(hdr[0],
184 MCDI_HEADER_CODE, emrp->emr_cmd,
185 MCDI_HEADER_RESYNC, 1,
186 MCDI_HEADER_DATALEN, emrp->emr_in_length,
187 MCDI_HEADER_SEQ, seq,
188 MCDI_HEADER_NOT_EPOCH, new_epoch ? 0 : 1,
189 MCDI_HEADER_ERROR, 0,
190 MCDI_HEADER_RESPONSE, 0,
191 MCDI_HEADER_XFLAGS, xflags);
192 EFSYS_MEM_WRITED(esmp, 0, &hdr[0]);
193 offset += sizeof (efx_dword_t);
194 }
195
196#if EFSYS_OPT_MCDI_LOGGING
197 if (emtp->emt_logger != NULL) {
198 emtp->emt_logger(emtp->emt_context, EFX_LOG_MCDI_REQUEST,
199 &hdr, offset,
200 emrp->emr_in_buf, emrp->emr_in_length);
201 }
202#endif /* EFSYS_OPT_MCDI_LOGGING */
203
204 /* Construct the payload */
205 for (pos = 0; pos < emrp->emr_in_length; pos += sizeof (efx_dword_t)) {
206 memcpy(&dword, MCDI_IN(*emrp, efx_dword_t, pos),
207 MIN(sizeof (dword), emrp->emr_in_length - pos));
208 EFSYS_MEM_WRITED(esmp, offset + pos, &dword);
209 }
210
211 /* Ring the doorbell to post the command DMA address to the MC */
212 EFSYS_ASSERT((EFSYS_MEM_ADDR(esmp) & 0xFF) == 0);
213
214 /* Guarantee ordering of memory (MCDI request) and PIO (MC doorbell) */
215 EFSYS_DMA_SYNC_FOR_DEVICE(esmp, 0, offset + emrp->emr_in_length);
216 EFSYS_PIO_WRITE_BARRIER();
217
218 EFX_POPULATE_DWORD_1(dword,
219 EFX_DWORD_0, EFSYS_MEM_ADDR(esmp) >> 32);
220 EFX_BAR_WRITED(enp, ER_DZ_MC_DB_LWRD_REG, &dword, B_FALSE);
221
222 EFX_POPULATE_DWORD_1(dword,
223 EFX_DWORD_0, EFSYS_MEM_ADDR(esmp) & 0xffffffff);
224 EFX_BAR_WRITED(enp, ER_DZ_MC_DB_HWRD_REG, &dword, B_FALSE);
225}
226
227 void
228hunt_mcdi_request_copyout(
229 __in efx_nic_t *enp,
230 __in efx_mcdi_req_t *emrp)
231{
|
| 232#if EFSYS_OPT_MCDI_LOGGING
|
232 const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
| 233 const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
|
233 efsys_mem_t *esmp = emtp->emt_dma_mem;
234 unsigned int pos;
235 unsigned int offset;
| 234#endif /* EFSYS_OPT_MCDI_LOGGING */
|
236 efx_dword_t hdr[2];
| 235 efx_dword_t hdr[2];
|
237 efx_dword_t data;
| 236 unsigned int hdr_len;
|
238 size_t bytes;
239
240 if (emrp->emr_out_buf == NULL)
241 return;
242
243 /* Read the command header to detect MCDI response format */
| 237 size_t bytes;
238
239 if (emrp->emr_out_buf == NULL)
240 return;
241
242 /* Read the command header to detect MCDI response format */
|
244 EFSYS_MEM_READD(esmp, 0, &hdr[0]);
| 243 hdr_len = sizeof (hdr[0]);
244 hunt_mcdi_read_response(enp, &hdr[0], 0, hdr_len);
|
245 if (EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_CODE) == MC_CMD_V2_EXTN) {
| 245 if (EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_CODE) == MC_CMD_V2_EXTN) {
|
246 offset = 2 * sizeof (efx_dword_t);
247
| |
248 /*
249 * Read the actual payload length. The length given in the event
250 * is only correct for responses with the V1 format.
251 */
| 246 /*
247 * Read the actual payload length. The length given in the event
248 * is only correct for responses with the V1 format.
249 */
|
252 EFSYS_MEM_READD(esmp, sizeof (efx_dword_t), &hdr[1]);
| 250 hunt_mcdi_read_response(enp, &hdr[1], hdr_len, sizeof (hdr[1]));
251 hdr_len += sizeof (hdr[1]);
252
|
253 emrp->emr_out_length_used = EFX_DWORD_FIELD(hdr[1],
254 MC_CMD_V2_EXTN_IN_ACTUAL_LEN);
| 253 emrp->emr_out_length_used = EFX_DWORD_FIELD(hdr[1],
254 MC_CMD_V2_EXTN_IN_ACTUAL_LEN);
|
255 } else {
256 offset = sizeof (efx_dword_t);
| |
257 }
258
259 /* Copy payload out into caller supplied buffer */
260 bytes = MIN(emrp->emr_out_length_used, emrp->emr_out_length);
| 255 }
256
257 /* Copy payload out into caller supplied buffer */
258 bytes = MIN(emrp->emr_out_length_used, emrp->emr_out_length);
|
261 for (pos = 0; pos < bytes; pos += sizeof (efx_dword_t)) {
262 EFSYS_MEM_READD(esmp, offset + pos, &data);
263 memcpy(MCDI_OUT(*emrp, efx_dword_t, pos), &data,
264 MIN(sizeof (data), bytes - pos));
265 }
| 259 hunt_mcdi_read_response(enp, emrp->emr_out_buf, hdr_len, bytes);
|
266
267#if EFSYS_OPT_MCDI_LOGGING
268 if (emtp->emt_logger != NULL) {
269 emtp->emt_logger(emtp->emt_context,
270 EFX_LOG_MCDI_RESPONSE,
| 260
261#if EFSYS_OPT_MCDI_LOGGING
262 if (emtp->emt_logger != NULL) {
263 emtp->emt_logger(emtp->emt_context,
264 EFX_LOG_MCDI_RESPONSE,
|
271 &hdr, offset,
272 emrp->emr_out_buf, emrp->emr_out_length_used);
| 265 &hdr, hdr_len,
266 emrp->emr_out_buf, bytes);
|
273 }
274#endif /* EFSYS_OPT_MCDI_LOGGING */
275}
276
277static __checkReturn boolean_t
278hunt_mcdi_poll_response(
279 __in efx_nic_t *enp)
280{
281 const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
282 efsys_mem_t *esmp = emtp->emt_dma_mem;
283 efx_dword_t hdr;
284
285 EFSYS_MEM_READD(esmp, 0, &hdr);
286 return (EFX_DWORD_FIELD(hdr, MCDI_HEADER_RESPONSE) ? B_TRUE : B_FALSE);
287}
288
| 267 }
268#endif /* EFSYS_OPT_MCDI_LOGGING */
269}
270
271static __checkReturn boolean_t
272hunt_mcdi_poll_response(
273 __in efx_nic_t *enp)
274{
275 const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
276 efsys_mem_t *esmp = emtp->emt_dma_mem;
277 efx_dword_t hdr;
278
279 EFSYS_MEM_READD(esmp, 0, &hdr);
280 return (EFX_DWORD_FIELD(hdr, MCDI_HEADER_RESPONSE) ? B_TRUE : B_FALSE);
281}
282
|
| 283 void
284hunt_mcdi_read_response(
285 __in efx_nic_t *enp,
286 __out void *bufferp,
287 __in size_t offset,
288 __in size_t length)
289{
290 const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
291 efsys_mem_t *esmp = emtp->emt_dma_mem;
292 unsigned int pos;
293 efx_dword_t data;
294
295 for (pos = 0; pos < length; pos += sizeof (efx_dword_t)) {
296 EFSYS_MEM_READD(esmp, offset + pos, &data);
297 memcpy((uint8_t *)bufferp + pos, &data,
298 MIN(sizeof (data), length - pos));
299 }
300}
301
|
289 __checkReturn boolean_t
290hunt_mcdi_request_poll(
291 __in efx_nic_t *enp)
292{
| 302 __checkReturn boolean_t
303hunt_mcdi_request_poll(
304 __in efx_nic_t *enp)
305{
|
293 efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
| 306#if EFSYS_OPT_MCDI_LOGGING
|
294 const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
| 307 const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
|
295 efsys_mem_t *esmp = emtp->emt_dma_mem;
| 308#endif /* EFSYS_OPT_MCDI_LOGGING */
309 efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
|
296 efx_mcdi_req_t *emrp;
297 efx_dword_t hdr[2];
| 310 efx_mcdi_req_t *emrp;
311 efx_dword_t hdr[2];
|
| 312 unsigned int hdr_len;
313 unsigned int data_len;
|
298 unsigned int seq;
299 unsigned int cmd;
| 314 unsigned int seq;
315 unsigned int cmd;
|
300 unsigned int length;
301 size_t offset;
| |
302 int state;
303 efx_rc_t rc;
304
305 EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
306
307 /* Serialise against post-watchdog efx_mcdi_ev* */
308 EFSYS_LOCK(enp->en_eslp, state);
309
310 EFSYS_ASSERT(emip->emi_pending_req != NULL);
311 EFSYS_ASSERT(!emip->emi_ev_cpl);
312 emrp = emip->emi_pending_req;
313
| 316 int state;
317 efx_rc_t rc;
318
319 EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
320
321 /* Serialise against post-watchdog efx_mcdi_ev* */
322 EFSYS_LOCK(enp->en_eslp, state);
323
324 EFSYS_ASSERT(emip->emi_pending_req != NULL);
325 EFSYS_ASSERT(!emip->emi_ev_cpl);
326 emrp = emip->emi_pending_req;
327
|
314 offset = 0;
315
| |
316 /* Check if a response is available */
317 if (hunt_mcdi_poll_response(enp) == B_FALSE) {
318 EFSYS_UNLOCK(enp->en_eslp, state);
319 return (B_FALSE);
320 }
321
322 /* Read the response header */
| 328 /* Check if a response is available */
329 if (hunt_mcdi_poll_response(enp) == B_FALSE) {
330 EFSYS_UNLOCK(enp->en_eslp, state);
331 return (B_FALSE);
332 }
333
334 /* Read the response header */
|
323 EFSYS_MEM_READD(esmp, offset, &hdr[0]);
324 offset += sizeof (efx_dword_t);
| 335 hdr_len = sizeof (hdr[0]);
336 hunt_mcdi_read_response(enp, &hdr[0], 0, hdr_len);
337
|
325 if (EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_CODE) == MC_CMD_V2_EXTN) {
| 338 if (EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_CODE) == MC_CMD_V2_EXTN) {
|
326 EFSYS_MEM_READD(esmp, offset, &hdr[1]);
327 offset += sizeof (efx_dword_t);
| 339 hunt_mcdi_read_response(enp, &hdr[1], hdr_len, sizeof (hdr[1]));
340 hdr_len += sizeof (hdr[1]);
|
328
329 cmd = EFX_DWORD_FIELD(hdr[1], MC_CMD_V2_EXTN_IN_EXTENDED_CMD);
| 341
342 cmd = EFX_DWORD_FIELD(hdr[1], MC_CMD_V2_EXTN_IN_EXTENDED_CMD);
|
330 length = EFX_DWORD_FIELD(hdr[1], MC_CMD_V2_EXTN_IN_ACTUAL_LEN);
| 343 data_len =
344 EFX_DWORD_FIELD(hdr[1], MC_CMD_V2_EXTN_IN_ACTUAL_LEN);
|
331 } else {
332 cmd = EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_CODE);
| 345 } else {
346 cmd = EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_CODE);
|
333 length = EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_DATALEN);
| 347 data_len = EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_DATALEN);
|
334 }
335
336 /* Request complete */
337 emip->emi_pending_req = NULL;
338 seq = (emip->emi_seq - 1) & EFX_MASK32(MCDI_HEADER_SEQ);
339
340 /* Check for synchronous reboot */
| 348 }
349
350 /* Request complete */
351 emip->emi_pending_req = NULL;
352 seq = (emip->emi_seq - 1) & EFX_MASK32(MCDI_HEADER_SEQ);
353
354 /* Check for synchronous reboot */
|
341 if (EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_ERROR) != 0 && length == 0) {
| 355 if (EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_ERROR) != 0 && data_len == 0) {
|
342 /* The MC has rebooted since the request was sent. */
343 EFSYS_SPIN(EFX_MCDI_STATUS_SLEEP_US);
344 hunt_mcdi_poll_reboot(enp);
345
346 EFSYS_UNLOCK(enp->en_eslp, state);
347 rc = EIO;
348 goto fail1;
349 }
350
351 /* Ensure stale MCDI requests fail after an MC reboot. */
352 emip->emi_new_epoch = B_FALSE;
353
354 EFSYS_UNLOCK(enp->en_eslp, state);
355
356 /* Check that the returned data is consistent */
357 if (cmd != emrp->emr_cmd ||
358 EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_SEQ) != seq) {
359 /* Response is for a different request */
360 rc = EIO;
361 goto fail2;
362 }
363 if (EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_ERROR)) {
364 efx_dword_t err[2];
| 356 /* The MC has rebooted since the request was sent. */
357 EFSYS_SPIN(EFX_MCDI_STATUS_SLEEP_US);
358 hunt_mcdi_poll_reboot(enp);
359
360 EFSYS_UNLOCK(enp->en_eslp, state);
361 rc = EIO;
362 goto fail1;
363 }
364
365 /* Ensure stale MCDI requests fail after an MC reboot. */
366 emip->emi_new_epoch = B_FALSE;
367
368 EFSYS_UNLOCK(enp->en_eslp, state);
369
370 /* Check that the returned data is consistent */
371 if (cmd != emrp->emr_cmd ||
372 EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_SEQ) != seq) {
373 /* Response is for a different request */
374 rc = EIO;
375 goto fail2;
376 }
377 if (EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_ERROR)) {
378 efx_dword_t err[2];
|
365 int errcode;
366 int argnum;
| 379 unsigned int err_len = MIN(data_len, sizeof (err));
380 int err_code = MC_CMD_ERR_EPROTO;
381 int err_arg = 0;
|
367
368 /* Read error code (and arg num for MCDI v2 commands) */
| 382
383 /* Read error code (and arg num for MCDI v2 commands) */
|
369 EFSYS_MEM_READD(esmp, offset + MC_CMD_ERR_CODE_OFST, &err[0]);
370 errcode = EFX_DWORD_FIELD(err[0], EFX_DWORD_0);
| 384 hunt_mcdi_read_response(enp, &err[0], hdr_len, err_len);
|
371
| 385
|
372 EFSYS_MEM_READD(esmp, offset + MC_CMD_ERR_ARG_OFST, &err[1]);
373 argnum = EFX_DWORD_FIELD(err[1], EFX_DWORD_0);
| 386 if (err_len >= MC_CMD_ERR_CODE_OFST + sizeof (efx_dword_t))
387 err_code = EFX_DWORD_FIELD(err[0], EFX_DWORD_0);
|
374
| 388
|
| 389 if (err_len >= MC_CMD_ERR_ARG_OFST + sizeof (efx_dword_t))
390 err_arg = EFX_DWORD_FIELD(err[1], EFX_DWORD_0);
391
|
375#if EFSYS_OPT_MCDI_LOGGING
376 if (emtp->emt_logger != NULL) {
377 emtp->emt_logger(emtp->emt_context,
378 EFX_LOG_MCDI_RESPONSE,
| 392#if EFSYS_OPT_MCDI_LOGGING
393 if (emtp->emt_logger != NULL) {
394 emtp->emt_logger(emtp->emt_context,
395 EFX_LOG_MCDI_RESPONSE,
|
379 &hdr, offset,
380 &err, sizeof (err));
| 396 &hdr, hdr_len,
397 &err, err_len);
|
381 }
382#endif /* EFSYS_OPT_MCDI_LOGGING */
383
| 398 }
399#endif /* EFSYS_OPT_MCDI_LOGGING */
400
|
384 rc = efx_mcdi_request_errcode(errcode);
| 401 rc = efx_mcdi_request_errcode(err_code);
|
385 if (!emrp->emr_quiet) {
386 EFSYS_PROBE3(mcdi_err_arg, int, emrp->emr_cmd,
| 402 if (!emrp->emr_quiet) {
403 EFSYS_PROBE3(mcdi_err_arg, int, emrp->emr_cmd,
|
387 int, errcode, int, argnum);
| 404 int, err_code, int, err_arg);
|
388 }
389 goto fail3;
390
391 } else {
| 405 }
406 goto fail3;
407
408 } else {
|
392 emrp->emr_out_length_used = length;
| 409 emrp->emr_out_length_used = data_len;
|
393 emrp->emr_rc = 0;
394 hunt_mcdi_request_copyout(enp, emrp);
395 }
396
397 goto out;
398
399fail3:
400 if (!emrp->emr_quiet)
401 EFSYS_PROBE(fail3);
402fail2:
403 if (!emrp->emr_quiet)
404 EFSYS_PROBE(fail2);
405fail1:
406 if (!emrp->emr_quiet)
407 EFSYS_PROBE1(fail1, efx_rc_t, rc);
408
409 /* Fill out error state */
410 emrp->emr_rc = rc;
411 emrp->emr_out_length_used = 0;
412
413 /* Reboot/Assertion */
414 if (rc == EIO || rc == EINTR)
415 efx_mcdi_raise_exception(enp, emrp, rc);
416
417out:
418 return (B_TRUE);
419}
420
421 efx_rc_t
422hunt_mcdi_poll_reboot(
423 __in efx_nic_t *enp)
424{
425 efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
426 efx_dword_t dword;
427 uint32_t old_status;
428 uint32_t new_status;
429 efx_rc_t rc;
430
431 old_status = emip->emi_mc_reboot_status;
432
433 /* Update MC reboot status word */
434 EFX_BAR_TBL_READD(enp, ER_DZ_BIU_MC_SFT_STATUS_REG, 0, &dword, B_FALSE);
435 new_status = dword.ed_u32[0];
436
437 /* MC has rebooted if the value has changed */
438 if (new_status != old_status) {
439 emip->emi_mc_reboot_status = new_status;
440
441 /*
442 * FIXME: Ignore detected MC REBOOT for now.
443 *
444 * The Siena support for checking for MC reboot from status
445 * flags is broken - see comments in siena_mcdi_poll_reboot().
446 * As the generic MCDI code is shared the Huntington reboot
447 * detection suffers similar problems.
448 *
449 * Do not report an error when the boot status changes until
450 * this can be handled by common code drivers (and reworked to
451 * support Siena too).
452 */
453 if (B_FALSE) {
454 rc = EIO;
455 goto fail1;
456 }
457 }
458
459 return (0);
460
461fail1:
462 EFSYS_PROBE1(fail1, efx_rc_t, rc);
463
464 return (rc);
465}
466
467 __checkReturn efx_rc_t
468hunt_mcdi_fw_update_supported(
469 __in efx_nic_t *enp,
470 __out boolean_t *supportedp)
471{
472 efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
473
474 EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
475
476 /*
477 * Use privilege mask state at MCDI attach.
478 * Admin privilege must be used prior to introduction of
479 * specific flag.
480 */
481 *supportedp = (encp->enc_privilege_mask &
482 MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN)
483 == MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN;
484
485 return (0);
486}
487
488 __checkReturn efx_rc_t
489hunt_mcdi_macaddr_change_supported(
490 __in efx_nic_t *enp,
491 __out boolean_t *supportedp)
492{
493 efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
494 uint32_t privilege_mask = encp->enc_privilege_mask;
495
496 EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
497
498 /*
499 * Use privilege mask state at MCDI attach.
500 * Admin privilege must be used prior to introduction of
501 * specific flag (at v4.6).
502 */
503 *supportedp =
504 ((privilege_mask & MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING) ==
505 MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING) ||
506 ((privilege_mask & MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN) ==
507 MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN);
508
509 return (0);
510}
511
512 __checkReturn efx_rc_t
513hunt_mcdi_link_control_supported(
514 __in efx_nic_t *enp,
515 __out boolean_t *supportedp)
516{
517 efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
518 uint32_t privilege_mask = encp->enc_privilege_mask;
519
520 EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
521
522 /*
523 * Use privilege mask state at MCDI attach.
524 * Admin privilege used prior to introduction of
525 * specific flag.
526 */
527 *supportedp =
528 ((privilege_mask & MC_CMD_PRIVILEGE_MASK_IN_GRP_LINK) ==
529 MC_CMD_PRIVILEGE_MASK_IN_GRP_LINK) ||
530 ((privilege_mask & MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN) ==
531 MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN);
532
533 return (0);
534}
535
536#endif /* EFSYS_OPT_MCDI */
537
538#endif /* EFSYS_OPT_HUNTINGTON */
| 410 emrp->emr_rc = 0;
411 hunt_mcdi_request_copyout(enp, emrp);
412 }
413
414 goto out;
415
416fail3:
417 if (!emrp->emr_quiet)
418 EFSYS_PROBE(fail3);
419fail2:
420 if (!emrp->emr_quiet)
421 EFSYS_PROBE(fail2);
422fail1:
423 if (!emrp->emr_quiet)
424 EFSYS_PROBE1(fail1, efx_rc_t, rc);
425
426 /* Fill out error state */
427 emrp->emr_rc = rc;
428 emrp->emr_out_length_used = 0;
429
430 /* Reboot/Assertion */
431 if (rc == EIO || rc == EINTR)
432 efx_mcdi_raise_exception(enp, emrp, rc);
433
434out:
435 return (B_TRUE);
436}
437
438 efx_rc_t
439hunt_mcdi_poll_reboot(
440 __in efx_nic_t *enp)
441{
442 efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
443 efx_dword_t dword;
444 uint32_t old_status;
445 uint32_t new_status;
446 efx_rc_t rc;
447
448 old_status = emip->emi_mc_reboot_status;
449
450 /* Update MC reboot status word */
451 EFX_BAR_TBL_READD(enp, ER_DZ_BIU_MC_SFT_STATUS_REG, 0, &dword, B_FALSE);
452 new_status = dword.ed_u32[0];
453
454 /* MC has rebooted if the value has changed */
455 if (new_status != old_status) {
456 emip->emi_mc_reboot_status = new_status;
457
458 /*
459 * FIXME: Ignore detected MC REBOOT for now.
460 *
461 * The Siena support for checking for MC reboot from status
462 * flags is broken - see comments in siena_mcdi_poll_reboot().
463 * As the generic MCDI code is shared the Huntington reboot
464 * detection suffers similar problems.
465 *
466 * Do not report an error when the boot status changes until
467 * this can be handled by common code drivers (and reworked to
468 * support Siena too).
469 */
470 if (B_FALSE) {
471 rc = EIO;
472 goto fail1;
473 }
474 }
475
476 return (0);
477
478fail1:
479 EFSYS_PROBE1(fail1, efx_rc_t, rc);
480
481 return (rc);
482}
483
484 __checkReturn efx_rc_t
485hunt_mcdi_fw_update_supported(
486 __in efx_nic_t *enp,
487 __out boolean_t *supportedp)
488{
489 efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
490
491 EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
492
493 /*
494 * Use privilege mask state at MCDI attach.
495 * Admin privilege must be used prior to introduction of
496 * specific flag.
497 */
498 *supportedp = (encp->enc_privilege_mask &
499 MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN)
500 == MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN;
501
502 return (0);
503}
504
505 __checkReturn efx_rc_t
506hunt_mcdi_macaddr_change_supported(
507 __in efx_nic_t *enp,
508 __out boolean_t *supportedp)
509{
510 efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
511 uint32_t privilege_mask = encp->enc_privilege_mask;
512
513 EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
514
515 /*
516 * Use privilege mask state at MCDI attach.
517 * Admin privilege must be used prior to introduction of
518 * specific flag (at v4.6).
519 */
520 *supportedp =
521 ((privilege_mask & MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING) ==
522 MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING) ||
523 ((privilege_mask & MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN) ==
524 MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN);
525
526 return (0);
527}
528
529 __checkReturn efx_rc_t
530hunt_mcdi_link_control_supported(
531 __in efx_nic_t *enp,
532 __out boolean_t *supportedp)
533{
534 efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
535 uint32_t privilege_mask = encp->enc_privilege_mask;
536
537 EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
538
539 /*
540 * Use privilege mask state at MCDI attach.
541 * Admin privilege used prior to introduction of
542 * specific flag.
543 */
544 *supportedp =
545 ((privilege_mask & MC_CMD_PRIVILEGE_MASK_IN_GRP_LINK) ==
546 MC_CMD_PRIVILEGE_MASK_IN_GRP_LINK) ||
547 ((privilege_mask & MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN) ==
548 MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN);
549
550 return (0);
551}
552
553#endif /* EFSYS_OPT_MCDI */
554
555#endif /* EFSYS_OPT_HUNTINGTON */
|