1 /*-
2 * Copyright 2009 Solarflare Communications Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23 * SUCH DAMAGE.
24 */
25
26 #include <sys/cdefs.h>
27 __FBSDID("$FreeBSD$");
28
29 #include "efsys.h"
30 #include "efx.h"
31 #include "efx_types.h"
32 #include "efx_impl.h"
33
34 #if EFSYS_OPT_WOL
35
36 __checkReturn int
efx_wol_init(__in efx_nic_t * enp)37 efx_wol_init(
38 __in efx_nic_t *enp)
39 {
40 efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
41 int rc;
42
43 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
44 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
45 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_WOL));
46
47 if (~(encp->enc_features) & EFX_FEATURE_WOL) {
48 rc = ENOTSUP;
49 goto fail1;
50 }
51
52 /* Current implementation is Siena specific */
53 EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_SIENA);
54
55 enp->en_mod_flags |= EFX_MOD_WOL;
56
57 return (0);
58
59 fail1:
60 EFSYS_PROBE1(fail1, int, rc);
61
62 return (rc);
63 }
64
65 __checkReturn int
efx_wol_filter_clear(__in efx_nic_t * enp)66 efx_wol_filter_clear(
67 __in efx_nic_t *enp)
68 {
69 efx_mcdi_req_t req;
70 uint8_t payload[MC_CMD_WOL_FILTER_RESET_IN_LEN];
71 int rc;
72
73 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
74 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_WOL);
75
76 req.emr_cmd = MC_CMD_WOL_FILTER_RESET;
77 req.emr_in_buf = payload;
78 req.emr_in_length = MC_CMD_WOL_FILTER_RESET_IN_LEN;
79 req.emr_out_buf = NULL;
80 req.emr_out_length = 0;
81
82 MCDI_IN_SET_DWORD(req, WOL_FILTER_RESET_IN_MASK,
83 MC_CMD_WOL_FILTER_RESET_IN_WAKE_FILTERS |
84 MC_CMD_WOL_FILTER_RESET_IN_LIGHTSOUT_OFFLOADS);
85
86 efx_mcdi_execute(enp, &req);
87
88 if (req.emr_rc != 0) {
89 rc = req.emr_rc;
90 goto fail1;
91 }
92
93 return (0);
94
95 fail1:
96 EFSYS_PROBE1(fail1, int, rc);
97
98 return (rc);
99 }
100
101 __checkReturn int
efx_wol_filter_add(__in efx_nic_t * enp,__in efx_wol_type_t type,__in efx_wol_param_t * paramp,__out uint32_t * filter_idp)102 efx_wol_filter_add(
103 __in efx_nic_t *enp,
104 __in efx_wol_type_t type,
105 __in efx_wol_param_t *paramp,
106 __out uint32_t *filter_idp)
107 {
108 efx_mcdi_req_t req;
109 uint8_t payload[MAX(MC_CMD_WOL_FILTER_SET_IN_LEN,
110 MC_CMD_WOL_FILTER_SET_OUT_LEN)];
111 efx_byte_t link_mask;
112 int rc;
113
114 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
115 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_WOL);
116
117 req.emr_cmd = MC_CMD_WOL_FILTER_SET;
118 (void) memset(payload, '\0', sizeof (payload));
119 req.emr_in_buf = payload;
120 req.emr_in_length = MC_CMD_WOL_FILTER_SET_IN_LEN;
121 req.emr_out_buf = payload;
122 req.emr_out_length = MC_CMD_WOL_FILTER_SET_OUT_LEN;
123
124 switch (type) {
125 case EFX_WOL_TYPE_MAGIC:
126 MCDI_IN_SET_DWORD(req, WOL_FILTER_SET_IN_FILTER_MODE,
127 MC_CMD_FILTER_MODE_SIMPLE);
128 MCDI_IN_SET_DWORD(req, WOL_FILTER_SET_IN_WOL_TYPE,
129 MC_CMD_WOL_TYPE_MAGIC);
130 EFX_MAC_ADDR_COPY(
131 MCDI_IN2(req, uint8_t, WOL_FILTER_SET_IN_MAGIC_MAC),
132 paramp->ewp_magic.mac_addr);
133 break;
134
135 case EFX_WOL_TYPE_BITMAP: {
136 uint32_t swapped = 0;
137 efx_dword_t *dwordp;
138 unsigned int pos, bit;
139
140 MCDI_IN_SET_DWORD(req, WOL_FILTER_SET_IN_FILTER_MODE,
141 MC_CMD_FILTER_MODE_SIMPLE);
142 MCDI_IN_SET_DWORD(req, WOL_FILTER_SET_IN_WOL_TYPE,
143 MC_CMD_WOL_TYPE_BITMAP);
144
145 /*
146 * MC bitmask is supposed to be bit swapped
147 * amongst 32 bit words(!)
148 */
149
150 dwordp = MCDI_IN2(req, efx_dword_t,
151 WOL_FILTER_SET_IN_BITMAP_MASK);
152
153 EFSYS_ASSERT3U(EFX_WOL_BITMAP_MASK_SIZE % 4, ==, 0);
154
155 for (pos = 0; pos < EFX_WOL_BITMAP_MASK_SIZE; ++pos) {
156 uint8_t native = paramp->ewp_bitmap.mask[pos];
157
158 for (bit = 0; bit < 8; ++bit) {
159 swapped <<= 1;
160 swapped |= (native & 0x1);
161 native >>= 1;
162 }
163
164 if ((pos & 3) == 3) {
165 EFX_POPULATE_DWORD_1(dwordp[pos >> 2],
166 EFX_DWORD_0, swapped);
167 swapped = 0;
168 }
169 }
170
171 memcpy(MCDI_IN2(req, uint8_t, WOL_FILTER_SET_IN_BITMAP_BITMAP),
172 paramp->ewp_bitmap.value,
173 sizeof (paramp->ewp_bitmap.value));
174
175 EFSYS_ASSERT3U(paramp->ewp_bitmap.value_len, <=,
176 sizeof (paramp->ewp_bitmap.value));
177 MCDI_IN_SET_DWORD(req, WOL_FILTER_SET_IN_BITMAP_LEN,
178 paramp->ewp_bitmap.value_len);
179 }
180 break;
181
182 case EFX_WOL_TYPE_LINK:
183 MCDI_IN_SET_DWORD(req, WOL_FILTER_SET_IN_FILTER_MODE,
184 MC_CMD_FILTER_MODE_SIMPLE);
185 MCDI_IN_SET_DWORD(req, WOL_FILTER_SET_IN_WOL_TYPE,
186 MC_CMD_WOL_TYPE_LINK);
187
188 EFX_ZERO_BYTE(link_mask);
189 EFX_SET_BYTE_FIELD(link_mask, MC_CMD_WOL_FILTER_SET_IN_LINK_UP,
190 1);
191 MCDI_IN_SET_BYTE(req, WOL_FILTER_SET_IN_LINK_MASK,
192 link_mask.eb_u8[0]);
193 break;
194
195 default:
196 EFSYS_ASSERT3U(type, !=, type);
197 }
198
199 efx_mcdi_execute(enp, &req);
200
201 if (req.emr_rc != 0) {
202 rc = req.emr_rc;
203 goto fail1;
204 }
205
206 if (req.emr_out_length_used < MC_CMD_WOL_FILTER_SET_OUT_LEN) {
207 rc = EMSGSIZE;
208 goto fail2;
209 }
210
211 *filter_idp = MCDI_OUT_DWORD(req, WOL_FILTER_SET_OUT_FILTER_ID);
212
213 return (0);
214
215 fail2:
216 EFSYS_PROBE(fail2);
217 fail1:
218 EFSYS_PROBE1(fail1, int, rc);
219
220 return (rc);
221 }
222
223 __checkReturn int
efx_wol_filter_remove(__in efx_nic_t * enp,__in uint32_t filter_id)224 efx_wol_filter_remove(
225 __in efx_nic_t *enp,
226 __in uint32_t filter_id)
227 {
228 efx_mcdi_req_t req;
229 uint8_t payload[MC_CMD_WOL_FILTER_REMOVE_IN_LEN];
230 int rc;
231
232 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
233 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_WOL);
234
235 req.emr_cmd = MC_CMD_WOL_FILTER_REMOVE;
236 req.emr_in_buf = payload;
237 req.emr_in_length = MC_CMD_WOL_FILTER_REMOVE_IN_LEN;
238 EFX_STATIC_ASSERT(MC_CMD_WOL_FILTER_REMOVE_OUT_LEN == 0);
239 req.emr_out_buf = NULL;
240 req.emr_out_length = 0;
241
242 MCDI_IN_SET_DWORD(req, WOL_FILTER_REMOVE_IN_FILTER_ID, filter_id);
243
244 efx_mcdi_execute(enp, &req);
245
246 if (req.emr_rc != 0) {
247 rc = req.emr_rc;
248 goto fail1;
249 }
250
251 return (0);
252
253 fail1:
254 EFSYS_PROBE1(fail1, int, rc);
255
256 return (rc);
257 }
258
259
260 __checkReturn int
efx_lightsout_offload_add(__in efx_nic_t * enp,__in efx_lightsout_offload_type_t type,__in efx_lightsout_offload_param_t * paramp,__out uint32_t * filter_idp)261 efx_lightsout_offload_add(
262 __in efx_nic_t *enp,
263 __in efx_lightsout_offload_type_t type,
264 __in efx_lightsout_offload_param_t *paramp,
265 __out uint32_t *filter_idp)
266 {
267 efx_mcdi_req_t req;
268 uint8_t payload[MAX(MAX(MC_CMD_ADD_LIGHTSOUT_OFFLOAD_IN_ARP_LEN,
269 MC_CMD_ADD_LIGHTSOUT_OFFLOAD_IN_NS_LEN),
270 MC_CMD_ADD_LIGHTSOUT_OFFLOAD_OUT_LEN)];
271 int rc;
272
273 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
274 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_WOL);
275
276 req.emr_cmd = MC_CMD_ADD_LIGHTSOUT_OFFLOAD;
277 req.emr_in_buf = payload;
278 req.emr_in_length = sizeof (type);
279 req.emr_out_buf = payload;
280 req.emr_out_length = MC_CMD_ADD_LIGHTSOUT_OFFLOAD_OUT_LEN;
281
282 switch (type) {
283 case EFX_LIGHTSOUT_OFFLOAD_TYPE_ARP:
284 req.emr_in_length = MC_CMD_ADD_LIGHTSOUT_OFFLOAD_IN_ARP_LEN;
285 MCDI_IN_SET_DWORD(req, ADD_LIGHTSOUT_OFFLOAD_IN_PROTOCOL,
286 MC_CMD_LIGHTSOUT_OFFLOAD_PROTOCOL_ARP);
287 EFX_MAC_ADDR_COPY(MCDI_IN2(req, uint8_t,
288 ADD_LIGHTSOUT_OFFLOAD_IN_ARP_MAC),
289 paramp->elop_arp.mac_addr);
290 MCDI_IN_SET_DWORD(req, ADD_LIGHTSOUT_OFFLOAD_IN_ARP_IP,
291 paramp->elop_arp.ip);
292 break;
293 case EFX_LIGHTSOUT_OFFLOAD_TYPE_NS:
294 req.emr_in_length = MC_CMD_ADD_LIGHTSOUT_OFFLOAD_IN_NS_LEN;
295 MCDI_IN_SET_DWORD(req, ADD_LIGHTSOUT_OFFLOAD_IN_PROTOCOL,
296 MC_CMD_LIGHTSOUT_OFFLOAD_PROTOCOL_NS);
297 EFX_MAC_ADDR_COPY(MCDI_IN2(req, uint8_t,
298 ADD_LIGHTSOUT_OFFLOAD_IN_NS_MAC),
299 paramp->elop_ns.mac_addr);
300 memcpy(MCDI_IN2(req, uint8_t,
301 ADD_LIGHTSOUT_OFFLOAD_IN_NS_SNIPV6),
302 paramp->elop_ns.solicited_node,
303 sizeof (paramp->elop_ns.solicited_node));
304 memcpy(MCDI_IN2(req, uint8_t, ADD_LIGHTSOUT_OFFLOAD_IN_NS_IPV6),
305 paramp->elop_ns.ip, sizeof (paramp->elop_ns.ip));
306 break;
307 default:
308 EFSYS_ASSERT3U(type, !=, type);
309 }
310
311 efx_mcdi_execute(enp, &req);
312
313 if (req.emr_rc != 0) {
314 rc = req.emr_rc;
315 goto fail1;
316 }
317
318 if (req.emr_out_length_used < MC_CMD_ADD_LIGHTSOUT_OFFLOAD_OUT_LEN) {
319 rc = EMSGSIZE;
320 goto fail2;
321 }
322
323 *filter_idp = MCDI_OUT_DWORD(req, ADD_LIGHTSOUT_OFFLOAD_OUT_FILTER_ID);
324
325 return (0);
326
327 fail2:
328 EFSYS_PROBE(fail2);
329 fail1:
330 EFSYS_PROBE1(fail1, int, rc);
331
332 return (rc);
333 }
334
335
336 __checkReturn int
efx_lightsout_offload_remove(__in efx_nic_t * enp,__in efx_lightsout_offload_type_t type,__in uint32_t filter_id)337 efx_lightsout_offload_remove(
338 __in efx_nic_t *enp,
339 __in efx_lightsout_offload_type_t type,
340 __in uint32_t filter_id)
341 {
342 efx_mcdi_req_t req;
343 uint8_t payload[MC_CMD_REMOVE_LIGHTSOUT_OFFLOAD_IN_LEN];
344 int rc;
345
346 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
347 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_WOL);
348
349 req.emr_cmd = MC_CMD_REMOVE_LIGHTSOUT_OFFLOAD;
350 req.emr_in_buf = payload;
351 req.emr_in_length = sizeof (payload);
352 EFX_STATIC_ASSERT(MC_CMD_REMOVE_LIGHTSOUT_OFFLOAD_OUT_LEN == 0);
353 req.emr_out_buf = NULL;
354 req.emr_out_length = 0;
355
356 switch (type) {
357 case EFX_LIGHTSOUT_OFFLOAD_TYPE_ARP:
358 MCDI_IN_SET_DWORD(req, REMOVE_LIGHTSOUT_OFFLOAD_IN_PROTOCOL,
359 MC_CMD_LIGHTSOUT_OFFLOAD_PROTOCOL_ARP);
360 break;
361 case EFX_LIGHTSOUT_OFFLOAD_TYPE_NS:
362 MCDI_IN_SET_DWORD(req, REMOVE_LIGHTSOUT_OFFLOAD_IN_PROTOCOL,
363 MC_CMD_LIGHTSOUT_OFFLOAD_PROTOCOL_NS);
364 break;
365 default:
366 EFSYS_ASSERT3U(type, !=, type);
367 }
368
369 MCDI_IN_SET_DWORD(req, REMOVE_LIGHTSOUT_OFFLOAD_IN_FILTER_ID,
370 filter_id);
371
372 efx_mcdi_execute(enp, &req);
373
374 if (req.emr_rc != 0) {
375 rc = req.emr_rc;
376 goto fail1;
377 }
378
379 return (0);
380
381 fail1:
382 EFSYS_PROBE1(fail1, int, rc);
383
384 return (rc);
385 }
386
387
388 void
efx_wol_fini(__in efx_nic_t * enp)389 efx_wol_fini(
390 __in efx_nic_t *enp)
391 {
392 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
393 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
394 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_WOL);
395
396 enp->en_mod_flags &= ~EFX_MOD_WOL;
397 }
398
399 #endif /* EFSYS_OPT_WOL */
400