Deleted Added
sdiff udiff text old ( 252869 ) new ( 257007 )
full compact
oce_sysctl.c (252869) oce_sysctl.c (257007)
1/*-
2 * Copyright (C) 2013 Emulex
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 *
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * 3. Neither the name of the Emulex Corporation nor the names of its
16 * contributors may be used to endorse or promote products derived from
17 * this software without specific prior written permission.
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, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 * Contact Information:
32 * freebsd-drivers@emulex.com
33 *
34 * Emulex
35 * 3333 Susan Street
36 * Costa Mesa, CA 92626
37 */
38
1/*-
2 * Copyright (C) 2013 Emulex
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 *
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * 3. Neither the name of the Emulex Corporation nor the names of its
16 * contributors may be used to endorse or promote products derived from
17 * this software without specific prior written permission.
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, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 * Contact Information:
32 * freebsd-drivers@emulex.com
33 *
34 * Emulex
35 * 3333 Susan Street
36 * Costa Mesa, CA 92626
37 */
38
39/* $FreeBSD: head/sys/dev/oce/oce_sysctl.c 252869 2013-07-06 08:30:45Z delphij $ */
39/* $FreeBSD: head/sys/dev/oce/oce_sysctl.c 257007 2013-10-23 18:58:38Z delphij $ */
40
40
41
42#include "oce_if.h"
43
44static void copy_stats_to_sc_xe201(POCE_SOFTC sc);
45static void copy_stats_to_sc_be3(POCE_SOFTC sc);
46static void copy_stats_to_sc_be2(POCE_SOFTC sc);
47static int oce_sysctl_loopback(SYSCTL_HANDLER_ARGS);
48static int oce_be3_fwupgrade(POCE_SOFTC sc, const struct firmware *fw);
41#include "oce_if.h"
42
43static void copy_stats_to_sc_xe201(POCE_SOFTC sc);
44static void copy_stats_to_sc_be3(POCE_SOFTC sc);
45static void copy_stats_to_sc_be2(POCE_SOFTC sc);
46static int oce_sysctl_loopback(SYSCTL_HANDLER_ARGS);
47static int oce_be3_fwupgrade(POCE_SOFTC sc, const struct firmware *fw);
48static int oce_skyhawk_fwupgrade(POCE_SOFTC sc, const struct firmware *fw);
49static int oce_sys_fwupgrade(SYSCTL_HANDLER_ARGS);
49static int oce_sys_fwupgrade(SYSCTL_HANDLER_ARGS);
50static int oce_be3_flashdata(POCE_SOFTC sc, const struct firmware
51 *fw, int num_imgs);
52static int oce_lancer_fwupgrade(POCE_SOFTC sc, const struct firmware *fw);
53static int oce_sysctl_sfp_vpd_dump(SYSCTL_HANDLER_ARGS);
54static boolean_t oce_phy_flashing_required(POCE_SOFTC sc);
55static boolean_t oce_img_flashing_required(POCE_SOFTC sc, const char *p,
56 int img_optype, uint32_t img_offset,
57 uint32_t img_size, uint32_t hdrs_size);
58static void oce_add_stats_sysctls_be3(POCE_SOFTC sc,
59 struct sysctl_ctx_list *ctx,
60 struct sysctl_oid *stats_node);
61static void oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
62 struct sysctl_ctx_list *ctx,
63 struct sysctl_oid *stats_node);
64
50static int oce_lancer_fwupgrade(POCE_SOFTC sc, const struct firmware *fw);
51static int oce_sysctl_sfp_vpd_dump(SYSCTL_HANDLER_ARGS);
52static boolean_t oce_phy_flashing_required(POCE_SOFTC sc);
53static boolean_t oce_img_flashing_required(POCE_SOFTC sc, const char *p,
54 int img_optype, uint32_t img_offset,
55 uint32_t img_size, uint32_t hdrs_size);
56static void oce_add_stats_sysctls_be3(POCE_SOFTC sc,
57 struct sysctl_ctx_list *ctx,
58 struct sysctl_oid *stats_node);
59static void oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
60 struct sysctl_ctx_list *ctx,
61 struct sysctl_oid *stats_node);
62
63
65extern char component_revision[32];
66uint32_t sfp_vpd_dump_buffer[TRANSCEIVER_DATA_NUM_ELE];
67
64extern char component_revision[32];
65uint32_t sfp_vpd_dump_buffer[TRANSCEIVER_DATA_NUM_ELE];
66
67struct flash_img_attri {
68 int img_offset;
69 int img_size;
70 int img_type;
71 bool skip_image;
72 int optype;
73};
74
68void
69oce_add_sysctls(POCE_SOFTC sc)
70{
71
72 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->dev);
73 struct sysctl_oid *tree = device_get_sysctl_tree(sc->dev);
74 struct sysctl_oid_list *child = SYSCTL_CHILDREN(tree);
75 struct sysctl_oid *stats_node;
76
77 SYSCTL_ADD_STRING(ctx, child,
78 OID_AUTO, "component_revision",
79 CTLTYPE_INT | CTLFLAG_RD,
80 &component_revision,
81 sizeof(component_revision),
82 "EMULEX One-Connect device driver revision");
83
84 SYSCTL_ADD_STRING(ctx, child,
85 OID_AUTO, "firmware_version",
86 CTLTYPE_INT | CTLFLAG_RD,
87 &sc->fw_version,
88 sizeof(sc->fw_version),
89 "EMULEX One-Connect Firmware Version");
90
91 SYSCTL_ADD_INT(ctx, child,
92 OID_AUTO, "max_rsp_handled",
93 CTLTYPE_INT | CTLFLAG_RW,
94 &oce_max_rsp_handled,
95 sizeof(oce_max_rsp_handled),
96 "Maximum receive frames handled per interupt");
97
98 if ((sc->function_mode & FNM_FLEX10_MODE) ||
99 (sc->function_mode & FNM_UMC_MODE))
100 SYSCTL_ADD_UINT(ctx, child,
101 OID_AUTO, "speed",
102 CTLFLAG_RD,
103 &sc->qos_link_speed,
104 0,"QOS Speed");
105 else
106 SYSCTL_ADD_UINT(ctx, child,
107 OID_AUTO, "speed",
108 CTLFLAG_RD,
109 &sc->speed,
110 0,"Link Speed");
111
112 if (sc->function_mode & FNM_UMC_MODE)
113 SYSCTL_ADD_UINT(ctx, child,
114 OID_AUTO, "pvid",
115 CTLFLAG_RD,
116 &sc->pvid,
117 0,"PVID");
118
119 SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "loop_back",
120 CTLTYPE_INT | CTLFLAG_RW, (void *)sc, 0,
121 oce_sysctl_loopback, "I", "Loop Back Tests");
122
123 SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "fw_upgrade",
124 CTLTYPE_STRING | CTLFLAG_RW, (void *)sc, 0,
125 oce_sys_fwupgrade, "A", "Firmware ufi file");
126
127 /*
128 * Dumps Transceiver data
129 * "sysctl dev.oce.0.sfp_vpd_dump=0"
130 * "sysctl -x dev.oce.0.sfp_vpd_dump_buffer" for hex dump
131 * "sysctl -b dev.oce.0.sfp_vpd_dump_buffer > sfp.bin" for binary dump
132 */
133 SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "sfp_vpd_dump",
134 CTLTYPE_INT | CTLFLAG_RW, (void *)sc, 0, oce_sysctl_sfp_vpd_dump,
135 "I", "Initiate a sfp_vpd_dump operation");
136 SYSCTL_ADD_OPAQUE(ctx, child, OID_AUTO, "sfp_vpd_dump_buffer",
137 CTLFLAG_RD, sfp_vpd_dump_buffer,
138 TRANSCEIVER_DATA_SIZE, "IU", "Access sfp_vpd_dump buffer");
139
140 stats_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
141 CTLFLAG_RD, NULL, "Ethernet Statistics");
142
143 if (IS_BE(sc) || IS_SH(sc))
144 oce_add_stats_sysctls_be3(sc, ctx, stats_node);
145 else
146 oce_add_stats_sysctls_xe201(sc, ctx, stats_node);
147
148
149}
150
151
152static uint32_t
153oce_loopback_test(struct oce_softc *sc, uint8_t loopback_type)
154{
155 uint32_t status = 0;
156
75void
76oce_add_sysctls(POCE_SOFTC sc)
77{
78
79 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->dev);
80 struct sysctl_oid *tree = device_get_sysctl_tree(sc->dev);
81 struct sysctl_oid_list *child = SYSCTL_CHILDREN(tree);
82 struct sysctl_oid *stats_node;
83
84 SYSCTL_ADD_STRING(ctx, child,
85 OID_AUTO, "component_revision",
86 CTLTYPE_INT | CTLFLAG_RD,
87 &component_revision,
88 sizeof(component_revision),
89 "EMULEX One-Connect device driver revision");
90
91 SYSCTL_ADD_STRING(ctx, child,
92 OID_AUTO, "firmware_version",
93 CTLTYPE_INT | CTLFLAG_RD,
94 &sc->fw_version,
95 sizeof(sc->fw_version),
96 "EMULEX One-Connect Firmware Version");
97
98 SYSCTL_ADD_INT(ctx, child,
99 OID_AUTO, "max_rsp_handled",
100 CTLTYPE_INT | CTLFLAG_RW,
101 &oce_max_rsp_handled,
102 sizeof(oce_max_rsp_handled),
103 "Maximum receive frames handled per interupt");
104
105 if ((sc->function_mode & FNM_FLEX10_MODE) ||
106 (sc->function_mode & FNM_UMC_MODE))
107 SYSCTL_ADD_UINT(ctx, child,
108 OID_AUTO, "speed",
109 CTLFLAG_RD,
110 &sc->qos_link_speed,
111 0,"QOS Speed");
112 else
113 SYSCTL_ADD_UINT(ctx, child,
114 OID_AUTO, "speed",
115 CTLFLAG_RD,
116 &sc->speed,
117 0,"Link Speed");
118
119 if (sc->function_mode & FNM_UMC_MODE)
120 SYSCTL_ADD_UINT(ctx, child,
121 OID_AUTO, "pvid",
122 CTLFLAG_RD,
123 &sc->pvid,
124 0,"PVID");
125
126 SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "loop_back",
127 CTLTYPE_INT | CTLFLAG_RW, (void *)sc, 0,
128 oce_sysctl_loopback, "I", "Loop Back Tests");
129
130 SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "fw_upgrade",
131 CTLTYPE_STRING | CTLFLAG_RW, (void *)sc, 0,
132 oce_sys_fwupgrade, "A", "Firmware ufi file");
133
134 /*
135 * Dumps Transceiver data
136 * "sysctl dev.oce.0.sfp_vpd_dump=0"
137 * "sysctl -x dev.oce.0.sfp_vpd_dump_buffer" for hex dump
138 * "sysctl -b dev.oce.0.sfp_vpd_dump_buffer > sfp.bin" for binary dump
139 */
140 SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "sfp_vpd_dump",
141 CTLTYPE_INT | CTLFLAG_RW, (void *)sc, 0, oce_sysctl_sfp_vpd_dump,
142 "I", "Initiate a sfp_vpd_dump operation");
143 SYSCTL_ADD_OPAQUE(ctx, child, OID_AUTO, "sfp_vpd_dump_buffer",
144 CTLFLAG_RD, sfp_vpd_dump_buffer,
145 TRANSCEIVER_DATA_SIZE, "IU", "Access sfp_vpd_dump buffer");
146
147 stats_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
148 CTLFLAG_RD, NULL, "Ethernet Statistics");
149
150 if (IS_BE(sc) || IS_SH(sc))
151 oce_add_stats_sysctls_be3(sc, ctx, stats_node);
152 else
153 oce_add_stats_sysctls_xe201(sc, ctx, stats_node);
154
155
156}
157
158
159static uint32_t
160oce_loopback_test(struct oce_softc *sc, uint8_t loopback_type)
161{
162 uint32_t status = 0;
163
157 oce_mbox_cmd_set_loopback(sc, sc->if_id, loopback_type, 1);
158 status = oce_mbox_cmd_test_loopback(sc, sc->if_id, loopback_type,
164 oce_mbox_cmd_set_loopback(sc, sc->port_id, loopback_type, 1);
165 status = oce_mbox_cmd_test_loopback(sc, sc->port_id, loopback_type,
159 1500, 2, 0xabc);
166 1500, 2, 0xabc);
160 oce_mbox_cmd_set_loopback(sc, sc->if_id, OCE_NO_LOOPBACK, 1);
167 oce_mbox_cmd_set_loopback(sc, sc->port_id, OCE_NO_LOOPBACK, 1);
161
162 return status;
163}
164
165static int
166oce_sysctl_loopback(SYSCTL_HANDLER_ARGS)
167{
168 int value = 0;
169 uint32_t status;
170 struct oce_softc *sc = (struct oce_softc *)arg1;
171
172 status = sysctl_handle_int(oidp, &value, 0, req);
173 if (status || !req->newptr)
174 return status;
175
176 if (value != 1) {
177 device_printf(sc->dev,
178 "Not a Valid value. Set to loop_back=1 to run tests\n");
179 return 0;
180 }
181
182 if ((status = oce_loopback_test(sc, OCE_MAC_LOOPBACK))) {
183 device_printf(sc->dev,
184 "MAC Loopback Test = Failed (Error status = %d)\n",
185 status);
186 } else
187 device_printf(sc->dev, "MAC Loopback Test = Success\n");
188
189 if ((status = oce_loopback_test(sc, OCE_PHY_LOOPBACK))) {
190 device_printf(sc->dev,
191 "PHY Loopback Test = Failed (Error status = %d)\n",
192 status);
193 } else
194 device_printf(sc->dev, "PHY Loopback Test = Success\n");
195
196 if ((status = oce_loopback_test(sc, OCE_ONE_PORT_EXT_LOOPBACK))) {
197 device_printf(sc->dev,
198 "EXT Loopback Test = Failed (Error status = %d)\n",
199 status);
200 } else
201 device_printf(sc->dev, "EXT Loopback Test = Success\n");
202
203 return 0;
204}
205
206
207static int
208oce_sys_fwupgrade(SYSCTL_HANDLER_ARGS)
209{
210 char ufiname[256] = {0};
211 uint32_t status = 1;
212 struct oce_softc *sc = (struct oce_softc *)arg1;
213 const struct firmware *fw;
214
215 status = sysctl_handle_string(oidp, ufiname, sizeof(ufiname), req);
216 if (status || !req->newptr)
217 return status;
218
219 fw = firmware_get(ufiname);
220 if (fw == NULL) {
221 device_printf(sc->dev, "Unable to get Firmware. "
222 "Make sure %s is copied to /boot/modules\n", ufiname);
223 return ENOENT;
224 }
225
168
169 return status;
170}
171
172static int
173oce_sysctl_loopback(SYSCTL_HANDLER_ARGS)
174{
175 int value = 0;
176 uint32_t status;
177 struct oce_softc *sc = (struct oce_softc *)arg1;
178
179 status = sysctl_handle_int(oidp, &value, 0, req);
180 if (status || !req->newptr)
181 return status;
182
183 if (value != 1) {
184 device_printf(sc->dev,
185 "Not a Valid value. Set to loop_back=1 to run tests\n");
186 return 0;
187 }
188
189 if ((status = oce_loopback_test(sc, OCE_MAC_LOOPBACK))) {
190 device_printf(sc->dev,
191 "MAC Loopback Test = Failed (Error status = %d)\n",
192 status);
193 } else
194 device_printf(sc->dev, "MAC Loopback Test = Success\n");
195
196 if ((status = oce_loopback_test(sc, OCE_PHY_LOOPBACK))) {
197 device_printf(sc->dev,
198 "PHY Loopback Test = Failed (Error status = %d)\n",
199 status);
200 } else
201 device_printf(sc->dev, "PHY Loopback Test = Success\n");
202
203 if ((status = oce_loopback_test(sc, OCE_ONE_PORT_EXT_LOOPBACK))) {
204 device_printf(sc->dev,
205 "EXT Loopback Test = Failed (Error status = %d)\n",
206 status);
207 } else
208 device_printf(sc->dev, "EXT Loopback Test = Success\n");
209
210 return 0;
211}
212
213
214static int
215oce_sys_fwupgrade(SYSCTL_HANDLER_ARGS)
216{
217 char ufiname[256] = {0};
218 uint32_t status = 1;
219 struct oce_softc *sc = (struct oce_softc *)arg1;
220 const struct firmware *fw;
221
222 status = sysctl_handle_string(oidp, ufiname, sizeof(ufiname), req);
223 if (status || !req->newptr)
224 return status;
225
226 fw = firmware_get(ufiname);
227 if (fw == NULL) {
228 device_printf(sc->dev, "Unable to get Firmware. "
229 "Make sure %s is copied to /boot/modules\n", ufiname);
230 return ENOENT;
231 }
232
226 if (IS_BE(sc) || IS_SH(sc)) {
233 if (IS_BE(sc)) {
227 if ((sc->flags & OCE_FLAGS_BE2)) {
228 device_printf(sc->dev,
229 "Flashing not supported for BE2 yet.\n");
230 status = 1;
231 goto done;
232 }
233 status = oce_be3_fwupgrade(sc, fw);
234 if ((sc->flags & OCE_FLAGS_BE2)) {
235 device_printf(sc->dev,
236 "Flashing not supported for BE2 yet.\n");
237 status = 1;
238 goto done;
239 }
240 status = oce_be3_fwupgrade(sc, fw);
241 } else if (IS_SH(sc)) {
242 status = oce_skyhawk_fwupgrade(sc,fw);
234 } else
235 status = oce_lancer_fwupgrade(sc, fw);
236done:
237 if (status) {
238 device_printf(sc->dev, "Firmware Upgrade failed\n");
239 } else {
240 device_printf(sc->dev, "Firmware Flashed successfully\n");
241 }
242
243 /* Release Firmware*/
244 firmware_put(fw, FIRMWARE_UNLOAD);
245
246 return status;
247}
248
243 } else
244 status = oce_lancer_fwupgrade(sc, fw);
245done:
246 if (status) {
247 device_printf(sc->dev, "Firmware Upgrade failed\n");
248 } else {
249 device_printf(sc->dev, "Firmware Flashed successfully\n");
250 }
251
252 /* Release Firmware*/
253 firmware_put(fw, FIRMWARE_UNLOAD);
254
255 return status;
256}
257
249
250static int
251oce_be3_fwupgrade(POCE_SOFTC sc, const struct firmware *fw)
258static void oce_fill_flash_img_data(POCE_SOFTC sc, const struct flash_sec_info * fsec,
259 struct flash_img_attri *pimg, int i,
260 const struct firmware *fw, int bin_offset)
252{
261{
253 int rc = 0, num_imgs = 0, i = 0;
254 const struct flash_file_hdr *fhdr;
255 const struct image_hdr *img_ptr;
256
257 fhdr = (const struct flash_file_hdr *)fw->data;
258 if (fhdr->build[0] != '3') {
259 device_printf(sc->dev, "Invalid BE3 firmware image\n");
260 return EINVAL;
262 if (IS_SH(sc)) {
263 pimg->img_offset = HOST_32(fsec->fsec_entry[i].offset);
264 pimg->img_size = HOST_32(fsec->fsec_entry[i].pad_size);
261 }
265 }
262 /* Display flash version */
263 device_printf(sc->dev, "Flashing Firmware %s\n", &fhdr->build[2]);
264
266
265 num_imgs = fhdr->num_imgs;
266 for (i = 0; i < num_imgs; i++) {
267 img_ptr = (const struct image_hdr *)((const char *)fw->data +
268 sizeof(struct flash_file_hdr) +
269 (i * sizeof(struct image_hdr)));
270 if (img_ptr->imageid == 1) {
271 rc = oce_be3_flashdata(sc, fw, num_imgs);
267 pimg->img_type = HOST_32(fsec->fsec_entry[i].type);
268 pimg->skip_image = FALSE;
269 switch (pimg->img_type) {
270 case IMG_ISCSI:
271 pimg->optype = 0;
272 if (IS_BE3(sc)) {
273 pimg->img_offset = 2097152;
274 pimg->img_size = 2097152;
275 }
272 break;
276 break;
273 }
277 case IMG_REDBOOT:
278 pimg->optype = 1;
279 if (IS_BE3(sc)) {
280 pimg->img_offset = 262144;
281 pimg->img_size = 1048576;
282 }
283 if (!oce_img_flashing_required(sc, fw->data,
284 pimg->optype,
285 pimg->img_offset,
286 pimg->img_size,
287 bin_offset))
288 pimg->skip_image = TRUE;
289 break;
290 case IMG_BIOS:
291 pimg->optype = 2;
292 if (IS_BE3(sc)) {
293 pimg->img_offset = 12582912;
294 pimg->img_size = 524288;
295 }
296 break;
297 case IMG_PXEBIOS:
298 pimg->optype = 3;
299 if (IS_BE3(sc)) {
300 pimg->img_offset = 13107200;;
301 pimg->img_size = 524288;
302 }
303 break;
304 case IMG_FCOEBIOS:
305 pimg->optype = 8;
306 if (IS_BE3(sc)) {
307 pimg->img_offset = 13631488;
308 pimg->img_size = 524288;
309 }
310 break;
311 case IMG_ISCSI_BAK:
312 pimg->optype = 9;
313 if (IS_BE3(sc)) {
314 pimg->img_offset = 4194304;
315 pimg->img_size = 2097152;
316 }
317 break;
318 case IMG_FCOE:
319 pimg->optype = 10;
320 if (IS_BE3(sc)) {
321 pimg->img_offset = 6291456;
322 pimg->img_size = 2097152;
323 }
324 break;
325 case IMG_FCOE_BAK:
326 pimg->optype = 11;
327 if (IS_BE3(sc)) {
328 pimg->img_offset = 8388608;
329 pimg->img_size = 2097152;
330 }
331 break;
332 case IMG_NCSI:
333 pimg->optype = 13;
334 if (IS_BE3(sc)) {
335 pimg->img_offset = 15990784;
336 pimg->img_size = 262144;
337 }
338 break;
339 case IMG_PHY:
340 pimg->optype = 99;
341 if (IS_BE3(sc)) {
342 pimg->img_offset = 1310720;
343 pimg->img_size = 262144;
344 }
345 if (!oce_phy_flashing_required(sc))
346 pimg->skip_image = TRUE;
347 break;
348 default:
349 pimg->skip_image = TRUE;
350 break;
274 }
275
351 }
352
276 return rc;
277}
278
353}
354
279
280static int
355static int
281oce_be3_flashdata(POCE_SOFTC sc, const struct firmware *fw, int num_imgs)
356oce_sh_be3_flashdata(POCE_SOFTC sc, const struct firmware *fw, int32_t num_imgs)
282{
283 char cookie[2][16] = {"*** SE FLAS", "H DIRECTORY *** "};
284 const char *p = (const char *)fw->data;
285 const struct flash_sec_info *fsec = NULL;
286 struct mbx_common_read_write_flashrom *req;
357{
358 char cookie[2][16] = {"*** SE FLAS", "H DIRECTORY *** "};
359 const char *p = (const char *)fw->data;
360 const struct flash_sec_info *fsec = NULL;
361 struct mbx_common_read_write_flashrom *req;
287 int rc = 0, i, img_type, bin_offset = 0;
288 boolean_t skip_image;
289 uint32_t optype = 0, size = 0, start = 0, num_bytes = 0;
290 uint32_t opcode = 0;
362 int rc = 0, i, bin_offset = 0, opcode, num_bytes;
291 OCE_DMA_MEM dma_mem;
363 OCE_DMA_MEM dma_mem;
364 struct flash_img_attri imgatt;
292
293 /* Validate Cookie */
294 bin_offset = (sizeof(struct flash_file_hdr) +
365
366 /* Validate Cookie */
367 bin_offset = (sizeof(struct flash_file_hdr) +
295 (num_imgs * sizeof(struct image_hdr)));
368 (num_imgs * sizeof(struct image_hdr)));
296 p += bin_offset;
297 while (p < ((const char *)fw->data + fw->datasize)) {
298 fsec = (const struct flash_sec_info *)p;
299 if (!memcmp(cookie, fsec->cookie, sizeof(cookie)))
300 break;
301 fsec = NULL;
302 p += 32;
303 }
304
305 if (!fsec) {
306 device_printf(sc->dev,
369 p += bin_offset;
370 while (p < ((const char *)fw->data + fw->datasize)) {
371 fsec = (const struct flash_sec_info *)p;
372 if (!memcmp(cookie, fsec->cookie, sizeof(cookie)))
373 break;
374 fsec = NULL;
375 p += 32;
376 }
377
378 if (!fsec) {
379 device_printf(sc->dev,
307 "Invalid Cookie. Firmware image corrupted ?\n");
380 "Invalid Cookie. Firmware image corrupted ?\n");
308 return EINVAL;
309 }
310
311 rc = oce_dma_alloc(sc, sizeof(struct mbx_common_read_write_flashrom)
312 + 32*1024, &dma_mem, 0);
313 if (rc) {
314 device_printf(sc->dev,
381 return EINVAL;
382 }
383
384 rc = oce_dma_alloc(sc, sizeof(struct mbx_common_read_write_flashrom)
385 + 32*1024, &dma_mem, 0);
386 if (rc) {
387 device_printf(sc->dev,
315 "Memory allocation failure while flashing\n");
388 "Memory allocation failure while flashing\n");
316 return ENOMEM;
317 }
318 req = OCE_DMAPTR(&dma_mem, struct mbx_common_read_write_flashrom);
319
389 return ENOMEM;
390 }
391 req = OCE_DMAPTR(&dma_mem, struct mbx_common_read_write_flashrom);
392
320 for (i = 0; i < MAX_FLASH_COMP; i++) {
393 if (IS_SH(sc))
394 num_imgs = HOST_32(fsec->fsec_hdr.num_images);
395 else if (IS_BE3(sc))
396 num_imgs = MAX_FLASH_COMP;
321
397
322 img_type = fsec->fsec_entry[i].type;
323 skip_image = FALSE;
324 switch (img_type) {
325 case IMG_ISCSI:
326 optype = 0;
327 size = 2097152;
328 start = 2097152;
329 break;
330 case IMG_REDBOOT:
331 optype = 1;
332 size = 1048576;
333 start = 262144;
334 if (!oce_img_flashing_required(sc, fw->data,
335 optype, start, size, bin_offset))
336 skip_image = TRUE;
337 break;
338 case IMG_BIOS:
339 optype = 2;
340 size = 524288;
341 start = 12582912;
342 break;
343 case IMG_PXEBIOS:
344 optype = 3;
345 size = 524288;
346 start = 13107200;
347 break;
348 case IMG_FCOEBIOS:
349 optype = 8;
350 size = 524288;
351 start = 13631488;
352 break;
353 case IMG_ISCSI_BAK:
354 optype = 9;
355 size = 2097152;
356 start = 4194304;
357 break;
358 case IMG_FCOE:
359 optype = 10;
360 size = 2097152;
361 start = 6291456;
362 break;
363 case IMG_FCOE_BAK:
364 optype = 11;
365 size = 2097152;
366 start = 8388608;
367 break;
368 case IMG_NCSI:
369 optype = 13;
370 size = 262144;
371 start = 15990784;
372 break;
373 case IMG_PHY:
374 optype = 99;
375 size = 262144;
376 start = 1310720;
377 if (!oce_phy_flashing_required(sc))
378 skip_image = TRUE;
379 break;
380 default:
381 skip_image = TRUE;
382 break;
383 }
384 if (skip_image)
398 for (i = 0; i < num_imgs; i++) {
399
400 bzero(&imgatt, sizeof(struct flash_img_attri));
401
402 oce_fill_flash_img_data(sc, fsec, &imgatt, i, fw, bin_offset);
403
404 if (imgatt.skip_image)
385 continue;
386
387 p = fw->data;
405 continue;
406
407 p = fw->data;
388 p = p + bin_offset + start;
389 if ((p + size) > ((const char *)fw->data + fw->datasize)) {
408 p = p + bin_offset + imgatt.img_offset;
409
410 if ((p + imgatt.img_size) > ((const char *)fw->data + fw->datasize)) {
390 rc = 1;
391 goto ret;
392 }
393
411 rc = 1;
412 goto ret;
413 }
414
394 while (size) {
415 while (imgatt.img_size) {
395
416
396 if (size > 32*1024)
417 if (imgatt.img_size > 32*1024)
397 num_bytes = 32*1024;
398 else
418 num_bytes = 32*1024;
419 else
399 num_bytes = size;
400 size -= num_bytes;
420 num_bytes = imgatt.img_size;
421 imgatt.img_size -= num_bytes;
401
422
402 if (!size)
423 if (!imgatt.img_size)
403 opcode = FLASHROM_OPER_FLASH;
404 else
405 opcode = FLASHROM_OPER_SAVE;
406
407 memcpy(req->data_buffer, p, num_bytes);
408 p += num_bytes;
409
424 opcode = FLASHROM_OPER_FLASH;
425 else
426 opcode = FLASHROM_OPER_SAVE;
427
428 memcpy(req->data_buffer, p, num_bytes);
429 p += num_bytes;
430
410 rc = oce_mbox_write_flashrom(sc, optype, opcode,
411 &dma_mem, num_bytes);
431 rc = oce_mbox_write_flashrom(sc, imgatt.optype, opcode,
432 &dma_mem, num_bytes);
412 if (rc) {
413 device_printf(sc->dev,
433 if (rc) {
434 device_printf(sc->dev,
414 "cmd to write to flash rom failed.\n");
435 "cmd to write to flash rom failed.\n");
415 rc = EIO;
416 goto ret;
417 }
418 /* Leave the CPU for others for some time */
419 pause("yield", 10);
420
421 }
436 rc = EIO;
437 goto ret;
438 }
439 /* Leave the CPU for others for some time */
440 pause("yield", 10);
441
442 }
443
422 }
444 }
445
423ret:
424 oce_dma_free(sc, &dma_mem);
425 return rc;
446ret:
447 oce_dma_free(sc, &dma_mem);
448 return rc;
449}
426
450
451#define UFI_TYPE2 2
452#define UFI_TYPE3 3
453#define UFI_TYPE3R 10
454#define UFI_TYPE4 4
455#define UFI_TYPE4R 11
456static int oce_get_ufi_type(POCE_SOFTC sc,
457 const struct flash_file_hdr *fhdr)
458{
459 if (fhdr == NULL)
460 goto be_get_ufi_exit;
461
462 if (IS_SH(sc) && fhdr->build[0] == '4') {
463 if (fhdr->asic_type_rev >= 0x10)
464 return UFI_TYPE4R;
465 else
466 return UFI_TYPE4;
467 } else if (IS_BE3(sc) && fhdr->build[0] == '3') {
468 if (fhdr->asic_type_rev == 0x10)
469 return UFI_TYPE3R;
470 else
471 return UFI_TYPE3;
472 } else if (IS_BE2(sc) && fhdr->build[0] == '2')
473 return UFI_TYPE2;
474
475be_get_ufi_exit:
476 device_printf(sc->dev,
477 "UFI and Interface are not compatible for flashing\n");
478 return -1;
427}
428
429
479}
480
481
482static int
483oce_skyhawk_fwupgrade(POCE_SOFTC sc, const struct firmware *fw)
484{
485 int rc = 0, num_imgs = 0, i = 0, ufi_type;
486 const struct flash_file_hdr *fhdr;
487 const struct image_hdr *img_ptr;
488
489 fhdr = (const struct flash_file_hdr *)fw->data;
490
491 ufi_type = oce_get_ufi_type(sc, fhdr);
492
493 /* Display flash version */
494 device_printf(sc->dev, "Flashing Firmware %s\n", &fhdr->build[2]);
495
496 num_imgs = fhdr->num_imgs;
497 for (i = 0; i < num_imgs; i++) {
498 img_ptr = (const struct image_hdr *)((const char *)fw->data +
499 sizeof(struct flash_file_hdr) +
500 (i * sizeof(struct image_hdr)));
501
502 if (img_ptr->imageid != 1)
503 continue;
504
505 switch (ufi_type) {
506 case UFI_TYPE4R:
507 rc = oce_sh_be3_flashdata(sc, fw,
508 num_imgs);
509 break;
510 case UFI_TYPE4:
511 if (sc->asic_revision < 0x10)
512 rc = oce_sh_be3_flashdata(sc, fw,
513 num_imgs);
514 else {
515 rc = -1;
516 device_printf(sc->dev,
517 "Cant load SH A0 UFI on B0\n");
518 }
519 break;
520 default:
521 rc = -1;
522 break;
523
524 }
525 }
526
527 return rc;
528}
529
530static int
531oce_be3_fwupgrade(POCE_SOFTC sc, const struct firmware *fw)
532{
533 int rc = 0, num_imgs = 0, i = 0;
534 const struct flash_file_hdr *fhdr;
535 const struct image_hdr *img_ptr;
536
537 fhdr = (const struct flash_file_hdr *)fw->data;
538 if (fhdr->build[0] != '3') {
539 device_printf(sc->dev, "Invalid BE3 firmware image\n");
540 return EINVAL;
541 }
542 /* Display flash version */
543 device_printf(sc->dev, "Flashing Firmware %s\n", &fhdr->build[2]);
544
545 num_imgs = fhdr->num_imgs;
546 for (i = 0; i < num_imgs; i++) {
547 img_ptr = (const struct image_hdr *)((const char *)fw->data +
548 sizeof(struct flash_file_hdr) +
549 (i * sizeof(struct image_hdr)));
550 if (img_ptr->imageid == 1) {
551 rc = oce_sh_be3_flashdata(sc, fw, num_imgs);
552
553 break;
554 }
555 }
556
557 return rc;
558}
559
560
430static boolean_t
431oce_phy_flashing_required(POCE_SOFTC sc)
432{
433 int status = 0;
434 struct oce_phy_info phy_info;
435
436 status = oce_mbox_get_phy_info(sc, &phy_info);
437 if (status)
438 return FALSE;
439
440 if ((phy_info.phy_type == TN_8022) &&
441 (phy_info.interface_type == PHY_TYPE_BASET_10GB)) {
442 return TRUE;
443 }
444
445 return FALSE;
446}
447
448
449static boolean_t
450oce_img_flashing_required(POCE_SOFTC sc, const char *p,
451 int img_optype, uint32_t img_offset,
452 uint32_t img_size, uint32_t hdrs_size)
453{
454 uint32_t crc_offset;
455 uint8_t flashed_crc[4];
456 int status;
457
458 crc_offset = hdrs_size + img_offset + img_size - 4;
459
460 p += crc_offset;
461
462 status = oce_mbox_get_flashrom_crc(sc, flashed_crc,
463 (img_size - 4), img_optype);
464 if (status)
465 return TRUE; /* Some thing worng. ReFlash */
466
467 /*update redboot only if crc does not match*/
468 if (bcmp(flashed_crc, p, 4))
469 return TRUE;
470 else
471 return FALSE;
472}
473
474
475static int
476oce_lancer_fwupgrade(POCE_SOFTC sc, const struct firmware *fw)
477{
478
479 int rc = 0;
480 OCE_DMA_MEM dma_mem;
481 const uint8_t *data = NULL;
482 uint8_t *dest_image_ptr = NULL;
483 size_t size = 0;
484 uint32_t data_written = 0, chunk_size = 0;
485 uint32_t offset = 0, add_status = 0;
486
487 if (!IS_ALIGNED(fw->datasize, sizeof(uint32_t))) {
488 device_printf(sc->dev,
489 "Lancer FW image is not 4 byte aligned.");
490 return EINVAL;
491 }
492
493 rc = oce_dma_alloc(sc, 32*1024, &dma_mem, 0);
494 if (rc) {
495 device_printf(sc->dev,
496 "Memory allocation failure while flashing Lancer\n");
497 return ENOMEM;
498 }
499
500 size = fw->datasize;
501 data = fw->data;
502 dest_image_ptr = OCE_DMAPTR(&dma_mem, uint8_t);
503
504 while (size) {
505 chunk_size = MIN(size, (32*1024));
506
507 bcopy(data, dest_image_ptr, chunk_size);
508
509 rc = oce_mbox_lancer_write_flashrom(sc, chunk_size, offset,
510 &dma_mem, &data_written, &add_status);
511
512 if (rc)
513 break;
514
515 size -= data_written;
516 data += data_written;
517 offset += data_written;
518 pause("yield", 10);
519
520 }
521
522 if (!rc)
523 /* Commit the firmware*/
524 rc = oce_mbox_lancer_write_flashrom(sc, 0, offset, &dma_mem,
525 &data_written, &add_status);
526 if (rc) {
527 device_printf(sc->dev, "Lancer firmware load error. "
528 "Addstatus = 0x%x, status = %d \n", add_status, rc);
529 rc = EIO;
530 }
531 oce_dma_free(sc, &dma_mem);
532 return rc;
533
534}
535
536
537static void
538oce_add_stats_sysctls_be3(POCE_SOFTC sc,
539 struct sysctl_ctx_list *ctx,
540 struct sysctl_oid *stats_node)
541{
542 struct sysctl_oid *rx_stats_node, *tx_stats_node;
543 struct sysctl_oid_list *rx_stat_list, *tx_stat_list;
544 struct sysctl_oid_list *queue_stats_list;
545 struct sysctl_oid *queue_stats_node;
546 struct oce_drv_stats *stats;
547 char prefix[32];
548 int i;
549
550 stats = &sc->oce_stats_info;
551
552 rx_stats_node = SYSCTL_ADD_NODE(ctx,
553 SYSCTL_CHILDREN(stats_node),
554 OID_AUTO,"rx", CTLFLAG_RD,
555 NULL, "RX Ethernet Statistics");
556 rx_stat_list = SYSCTL_CHILDREN(rx_stats_node);
557
558
559 SYSCTL_ADD_QUAD(ctx, rx_stat_list, OID_AUTO, "total_pkts",
560 CTLFLAG_RD, &stats->rx.t_rx_pkts,
561 "Total Received Packets");
562 SYSCTL_ADD_QUAD(ctx, rx_stat_list, OID_AUTO, "total_bytes",
563 CTLFLAG_RD, &stats->rx.t_rx_bytes,
564 "Total Received Bytes");
565 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_frags",
566 CTLFLAG_RD, &stats->rx.t_rx_frags, 0,
567 "Total Received Fragements");
568 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_mcast_pkts",
569 CTLFLAG_RD, &stats->rx.t_rx_mcast_pkts, 0,
570 "Total Received Multicast Packets");
571 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_ucast_pkts",
572 CTLFLAG_RD, &stats->rx.t_rx_ucast_pkts, 0,
573 "Total Received Unicast Packets");
574 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_rxcp_errs",
575 CTLFLAG_RD, &stats->rx.t_rxcp_errs, 0,
576 "Total Receive completion errors");
577 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "pause_frames",
578 CTLFLAG_RD, &stats->u0.be.rx_pause_frames, 0,
579 "Pause Frames");
580 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "priority_pause_frames",
581 CTLFLAG_RD, &stats->u0.be.rx_priority_pause_frames, 0,
582 "Priority Pause Frames");
583 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "control_frames",
584 CTLFLAG_RD, &stats->u0.be.rx_control_frames, 0,
585 "Control Frames");
586
587 for (i = 0; i < sc->nrqs; i++) {
588 sprintf(prefix, "queue%d",i);
589 queue_stats_node = SYSCTL_ADD_NODE(ctx,
590 SYSCTL_CHILDREN(rx_stats_node),
591 OID_AUTO, prefix, CTLFLAG_RD,
592 NULL, "Queue name");
593 queue_stats_list = SYSCTL_CHILDREN(queue_stats_node);
594
595 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "rx_pkts",
596 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_pkts,
597 "Receive Packets");
598 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "rx_bytes",
599 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_bytes,
600 "Recived Bytes");
601 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "rx_frags",
602 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_frags, 0,
603 "Received Fragments");
604 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO,
605 "rx_mcast_pkts", CTLFLAG_RD,
606 &sc->rq[i]->rx_stats.rx_mcast_pkts, 0,
607 "Received Multicast Packets");
608 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO,
609 "rx_ucast_pkts", CTLFLAG_RD,
610 &sc->rq[i]->rx_stats.rx_ucast_pkts, 0,
611 "Received Unicast Packets");
612 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "rxcp_err",
613 CTLFLAG_RD, &sc->rq[i]->rx_stats.rxcp_err, 0,
614 "Received Completion Errors");
615
616 }
617
618 rx_stats_node = SYSCTL_ADD_NODE(ctx,
619 SYSCTL_CHILDREN(rx_stats_node),
620 OID_AUTO, "err", CTLFLAG_RD,
621 NULL, "Receive Error Stats");
622 rx_stat_list = SYSCTL_CHILDREN(rx_stats_node);
623
624 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "crc_errs",
625 CTLFLAG_RD, &stats->u0.be.rx_crc_errors, 0,
626 "CRC Errors");
627 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "pbuf_errors",
628 CTLFLAG_RD, &stats->u0.be.rx_drops_no_pbuf, 0,
629 "Drops due to pbuf full");
630 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "erx_errors",
631 CTLFLAG_RD, &stats->u0.be.rx_drops_no_erx_descr, 0,
632 "ERX Errors");
633 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "alignment_errors",
634 CTLFLAG_RD, &stats->u0.be.rx_drops_too_many_frags, 0,
635 "RX Alignmnet Errors");
636 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "in_range_errors",
637 CTLFLAG_RD, &stats->u0.be.rx_in_range_errors, 0,
638 "In Range Errors");
639 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "out_range_errors",
640 CTLFLAG_RD, &stats->u0.be.rx_out_range_errors, 0,
641 "Out Range Errors");
642 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "frame_too_long",
643 CTLFLAG_RD, &stats->u0.be.rx_frame_too_long, 0,
644 "Frame Too Long");
645 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "address_match_errors",
646 CTLFLAG_RD, &stats->u0.be.rx_address_match_errors, 0,
647 "Address Match Errors");
648 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_too_small",
649 CTLFLAG_RD, &stats->u0.be.rx_dropped_too_small, 0,
650 "Dropped Too Small");
651 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_too_short",
652 CTLFLAG_RD, &stats->u0.be.rx_dropped_too_short, 0,
653 "Dropped Too Short");
654 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO,
655 "dropped_header_too_small", CTLFLAG_RD,
656 &stats->u0.be.rx_dropped_header_too_small, 0,
657 "Dropped Header Too Small");
658 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_tcp_length",
659 CTLFLAG_RD, &stats->u0.be.rx_dropped_tcp_length, 0,
660 "Dropped TCP Length");
661 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_runt",
662 CTLFLAG_RD, &stats->u0.be.rx_dropped_runt, 0,
663 "Dropped runt");
664 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "ip_checksum_errs",
665 CTLFLAG_RD, &stats->u0.be.rx_ip_checksum_errs, 0,
666 "IP Checksum Errors");
667 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "tcp_checksum_errs",
668 CTLFLAG_RD, &stats->u0.be.rx_tcp_checksum_errs, 0,
669 "TCP Checksum Errors");
670 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "udp_checksum_errs",
671 CTLFLAG_RD, &stats->u0.be.rx_udp_checksum_errs, 0,
672 "UDP Checksum Errors");
673 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "fifo_overflow_drop",
674 CTLFLAG_RD, &stats->u0.be.rxpp_fifo_overflow_drop, 0,
675 "FIFO Overflow Drop");
676 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO,
677 "input_fifo_overflow_drop", CTLFLAG_RD,
678 &stats->u0.be.rx_input_fifo_overflow_drop, 0,
679 "Input FIFO Overflow Drop");
680
681 tx_stats_node = SYSCTL_ADD_NODE(ctx,
682 SYSCTL_CHILDREN(stats_node), OID_AUTO,
683 "tx",CTLFLAG_RD, NULL,
684 "TX Ethernet Statistics");
685 tx_stat_list = SYSCTL_CHILDREN(tx_stats_node);
686
687 SYSCTL_ADD_QUAD(ctx, tx_stat_list, OID_AUTO, "total_tx_pkts",
688 CTLFLAG_RD, &stats->tx.t_tx_pkts,
689 "Total Transmit Packets");
690 SYSCTL_ADD_QUAD(ctx, tx_stat_list, OID_AUTO, "total_tx_bytes",
691 CTLFLAG_RD, &stats->tx.t_tx_bytes,
692 "Total Transmit Bytes");
693 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_reqs",
694 CTLFLAG_RD, &stats->tx.t_tx_reqs, 0,
695 "Total Transmit Requests");
696 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_stops",
697 CTLFLAG_RD, &stats->tx.t_tx_stops, 0,
698 "Total Transmit Stops");
699 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_wrbs",
700 CTLFLAG_RD, &stats->tx.t_tx_wrbs, 0,
701 "Total Transmit WRB's");
702 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_compl",
703 CTLFLAG_RD, &stats->tx.t_tx_compl, 0,
704 "Total Transmit Completions");
705 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO,
706 "total_ipv6_ext_hdr_tx_drop", CTLFLAG_RD,
707 &stats->tx.t_ipv6_ext_hdr_tx_drop, 0,
708 "Total Transmit IPV6 Drops");
709 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "pauseframes",
710 CTLFLAG_RD, &stats->u0.be.tx_pauseframes, 0,
711 "Pause Frames");
712 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "priority_pauseframes",
713 CTLFLAG_RD, &stats->u0.be.tx_priority_pauseframes, 0,
714 "Priority Pauseframes");
715 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "controlframes",
716 CTLFLAG_RD, &stats->u0.be.tx_controlframes, 0,
717 "Tx Control Frames");
718
719 for (i = 0; i < sc->nwqs; i++) {
720 sprintf(prefix, "queue%d",i);
721 queue_stats_node = SYSCTL_ADD_NODE(ctx,
722 SYSCTL_CHILDREN(tx_stats_node),
723 OID_AUTO, prefix, CTLFLAG_RD,
724 NULL, "Queue name");
725 queue_stats_list = SYSCTL_CHILDREN(queue_stats_node);
726
727 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "tx_pkts",
728 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_pkts,
729 "Transmit Packets");
730 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "tx_bytes",
731 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_bytes,
732 "Transmit Bytes");
733 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_reqs",
734 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_reqs, 0,
735 "Transmit Requests");
736 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_stops",
737 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_stops, 0,
738 "Transmit Stops");
739 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_wrbs",
740 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_wrbs, 0,
741 "Transmit WRB's");
742 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_compl",
743 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_compl, 0,
744 "Transmit Completions");
745 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO,
746 "ipv6_ext_hdr_tx_drop",CTLFLAG_RD,
747 &sc->wq[i]->tx_stats.ipv6_ext_hdr_tx_drop, 0,
748 "Transmit IPV6 Ext Header Drop");
749
750 }
751 return;
752}
753
754
755static void
756oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
757 struct sysctl_ctx_list *ctx,
758 struct sysctl_oid *stats_node)
759{
760 struct sysctl_oid *rx_stats_node, *tx_stats_node;
761 struct sysctl_oid_list *rx_stat_list, *tx_stat_list;
762 struct sysctl_oid_list *queue_stats_list;
763 struct sysctl_oid *queue_stats_node;
764 struct oce_drv_stats *stats;
765 char prefix[32];
766 int i;
767
768 stats = &sc->oce_stats_info;
769
770 rx_stats_node = SYSCTL_ADD_NODE(ctx,
771 SYSCTL_CHILDREN(stats_node),
772 OID_AUTO, "rx", CTLFLAG_RD,
773 NULL, "RX Ethernet Statistics");
774 rx_stat_list = SYSCTL_CHILDREN(rx_stats_node);
775
776
777 SYSCTL_ADD_QUAD(ctx, rx_stat_list, OID_AUTO, "total_pkts",
778 CTLFLAG_RD, &stats->rx.t_rx_pkts,
779 "Total Received Packets");
780 SYSCTL_ADD_QUAD(ctx, rx_stat_list, OID_AUTO, "total_bytes",
781 CTLFLAG_RD, &stats->rx.t_rx_bytes,
782 "Total Received Bytes");
783 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_frags",
784 CTLFLAG_RD, &stats->rx.t_rx_frags, 0,
785 "Total Received Fragements");
786 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_mcast_pkts",
787 CTLFLAG_RD, &stats->rx.t_rx_mcast_pkts, 0,
788 "Total Received Multicast Packets");
789 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_ucast_pkts",
790 CTLFLAG_RD, &stats->rx.t_rx_ucast_pkts, 0,
791 "Total Received Unicast Packets");
792 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_rxcp_errs",
793 CTLFLAG_RD, &stats->rx.t_rxcp_errs, 0,
794 "Total Receive completion errors");
795 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "pause_frames",
796 CTLFLAG_RD, &stats->u0.xe201.rx_pause_frames, 0,
797 "Pause Frames");
798 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "control_frames",
799 CTLFLAG_RD, &stats->u0.xe201.rx_control_frames, 0,
800 "Control Frames");
801
802 for (i = 0; i < sc->nrqs; i++) {
803 sprintf(prefix, "queue%d",i);
804 queue_stats_node = SYSCTL_ADD_NODE(ctx,
805 SYSCTL_CHILDREN(rx_stats_node),
806 OID_AUTO, prefix, CTLFLAG_RD,
807 NULL, "Queue name");
808 queue_stats_list = SYSCTL_CHILDREN(queue_stats_node);
809
810 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "rx_pkts",
811 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_pkts,
812 "Receive Packets");
813 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "rx_bytes",
814 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_bytes,
815 "Recived Bytes");
816 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "rx_frags",
817 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_frags, 0,
818 "Received Fragments");
819 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO,
820 "rx_mcast_pkts", CTLFLAG_RD,
821 &sc->rq[i]->rx_stats.rx_mcast_pkts, 0,
822 "Received Multicast Packets");
823 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO,
824 "rx_ucast_pkts",CTLFLAG_RD,
825 &sc->rq[i]->rx_stats.rx_ucast_pkts, 0,
826 "Received Unicast Packets");
827 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "rxcp_err",
828 CTLFLAG_RD, &sc->rq[i]->rx_stats.rxcp_err, 0,
829 "Received Completion Errors");
830
831 }
832
833 rx_stats_node = SYSCTL_ADD_NODE(ctx,
834 SYSCTL_CHILDREN(rx_stats_node),
835 OID_AUTO, "err", CTLFLAG_RD,
836 NULL, "Receive Error Stats");
837 rx_stat_list = SYSCTL_CHILDREN(rx_stats_node);
838
839 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "crc_errs",
840 CTLFLAG_RD, &stats->u0.xe201.rx_crc_errors, 0,
841 "CRC Errors");
842 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "alignment_errors",
843 CTLFLAG_RD, &stats->u0.xe201.rx_alignment_errors, 0,
844 "RX Alignmnet Errors");
845 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "in_range_errors",
846 CTLFLAG_RD, &stats->u0.xe201.rx_in_range_errors, 0,
847 "In Range Errors");
848 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "out_range_errors",
849 CTLFLAG_RD, &stats->u0.xe201.rx_out_of_range_errors, 0,
850 "Out Range Errors");
851 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "frame_too_long",
852 CTLFLAG_RD, &stats->u0.xe201.rx_frames_too_long, 0,
853 "Frame Too Long");
854 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "address_match_errors",
855 CTLFLAG_RD, &stats->u0.xe201.rx_address_match_errors, 0,
856 "Address Match Errors");
857 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_too_small",
858 CTLFLAG_RD, &stats->u0.xe201.rx_dropped_too_small, 0,
859 "Dropped Too Small");
860 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_too_short",
861 CTLFLAG_RD, &stats->u0.xe201.rx_dropped_too_short, 0,
862 "Dropped Too Short");
863 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO,
864 "dropped_header_too_small", CTLFLAG_RD,
865 &stats->u0.xe201.rx_dropped_header_too_small, 0,
866 "Dropped Header Too Small");
867 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO,
868 "dropped_tcp_length", CTLFLAG_RD,
869 &stats->u0.xe201.rx_dropped_invalid_tcp_length, 0,
870 "Dropped TCP Length");
871 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_runt",
872 CTLFLAG_RD, &stats->u0.xe201.rx_dropped_runt, 0,
873 "Dropped runt");
874 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "ip_checksum_errs",
875 CTLFLAG_RD, &stats->u0.xe201.rx_ip_checksum_errors, 0,
876 "IP Checksum Errors");
877 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "tcp_checksum_errs",
878 CTLFLAG_RD, &stats->u0.xe201.rx_tcp_checksum_errors, 0,
879 "TCP Checksum Errors");
880 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "udp_checksum_errs",
881 CTLFLAG_RD, &stats->u0.xe201.rx_udp_checksum_errors, 0,
882 "UDP Checksum Errors");
883 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "input_fifo_overflow_drop",
884 CTLFLAG_RD, &stats->u0.xe201.rx_fifo_overflow, 0,
885 "Input FIFO Overflow Drop");
886
887 tx_stats_node = SYSCTL_ADD_NODE(ctx,
888 SYSCTL_CHILDREN(stats_node),
889 OID_AUTO, "tx", CTLFLAG_RD,
890 NULL, "TX Ethernet Statistics");
891 tx_stat_list = SYSCTL_CHILDREN(tx_stats_node);
892
893 SYSCTL_ADD_QUAD(ctx, tx_stat_list, OID_AUTO, "total_tx_pkts",
894 CTLFLAG_RD, &stats->tx.t_tx_pkts,
895 "Total Transmit Packets");
896 SYSCTL_ADD_QUAD(ctx, tx_stat_list, OID_AUTO, "total_tx_bytes",
897 CTLFLAG_RD, &stats->tx.t_tx_bytes,
898 "Total Transmit Bytes");
899 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_reqs",
900 CTLFLAG_RD, &stats->tx.t_tx_reqs, 0,
901 "Total Transmit Requests");
902 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_stops",
903 CTLFLAG_RD, &stats->tx.t_tx_stops, 0,
904 "Total Transmit Stops");
905 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_wrbs",
906 CTLFLAG_RD, &stats->tx.t_tx_wrbs, 0,
907 "Total Transmit WRB's");
908 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_compl",
909 CTLFLAG_RD, &stats->tx.t_tx_compl, 0,
910 "Total Transmit Completions");
911 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO,
912 "total_ipv6_ext_hdr_tx_drop",
913 CTLFLAG_RD, &stats->tx.t_ipv6_ext_hdr_tx_drop, 0,
914 "Total Transmit IPV6 Drops");
915 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "pauseframes",
916 CTLFLAG_RD, &stats->u0.xe201.tx_pause_frames, 0,
917 "Pause Frames");
918 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "controlframes",
919 CTLFLAG_RD, &stats->u0.xe201.tx_control_frames, 0,
920 "Tx Control Frames");
921
922 for (i = 0; i < sc->nwqs; i++) {
923 sprintf(prefix, "queue%d",i);
924 queue_stats_node = SYSCTL_ADD_NODE(ctx,
925 SYSCTL_CHILDREN(tx_stats_node),
926 OID_AUTO, prefix, CTLFLAG_RD,
927 NULL, "Queue name");
928 queue_stats_list = SYSCTL_CHILDREN(queue_stats_node);
929
930 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "tx_pkts",
931 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_pkts,
932 "Transmit Packets");
933 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "tx_bytes",
934 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_bytes,
935 "Transmit Bytes");
936 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_reqs",
937 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_reqs, 0,
938 "Transmit Requests");
939 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_stops",
940 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_stops, 0,
941 "Transmit Stops");
942 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_wrbs",
943 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_wrbs, 0,
944 "Transmit WRB's");
945 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_compl",
946 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_compl, 0,
947 "Transmit Completions");
948 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO,
949 "ipv6_ext_hdr_tx_drop", CTLFLAG_RD,
950 &sc->wq[i]->tx_stats.ipv6_ext_hdr_tx_drop, 0,
951 "Transmit IPV6 Ext Header Drop");
952
953 }
954 return;
955}
956
957
958void
959oce_refresh_queue_stats(POCE_SOFTC sc)
960{
961 struct oce_drv_stats *adapter_stats;
962 int i;
963
964 adapter_stats = &sc->oce_stats_info;
965
966 /* Caluculate total TX and TXstats from all queues */
967
968 bzero(&adapter_stats->rx, sizeof(struct oce_rx_stats));
969 for (i = 0; i < sc->nrqs; i++) {
970
971 adapter_stats->rx.t_rx_pkts += sc->rq[i]->rx_stats.rx_pkts;
972 adapter_stats->rx.t_rx_bytes += sc->rq[i]->rx_stats.rx_bytes;
973 adapter_stats->rx.t_rx_frags += sc->rq[i]->rx_stats.rx_frags;
974 adapter_stats->rx.t_rx_mcast_pkts +=
975 sc->rq[i]->rx_stats.rx_mcast_pkts;
976 adapter_stats->rx.t_rx_ucast_pkts +=
977 sc->rq[i]->rx_stats.rx_ucast_pkts;
978 adapter_stats->rx.t_rxcp_errs += sc-> rq[i]->rx_stats.rxcp_err;
979 }
980
981 bzero(&adapter_stats->tx, sizeof(struct oce_tx_stats));
982 for (i = 0; i < sc->nwqs; i++) {
983 adapter_stats->tx.t_tx_reqs += sc->wq[i]->tx_stats.tx_reqs;
984 adapter_stats->tx.t_tx_stops += sc->wq[i]->tx_stats.tx_stops;
985 adapter_stats->tx.t_tx_wrbs += sc->wq[i]->tx_stats.tx_wrbs;
986 adapter_stats->tx.t_tx_compl += sc->wq[i]->tx_stats.tx_compl;
987 adapter_stats->tx.t_tx_bytes += sc->wq[i]->tx_stats.tx_bytes;
988 adapter_stats->tx.t_tx_pkts += sc->wq[i]->tx_stats.tx_pkts;
989 adapter_stats->tx.t_ipv6_ext_hdr_tx_drop +=
990 sc->wq[i]->tx_stats.ipv6_ext_hdr_tx_drop;
991 }
992
993}
994
995
996
997static void
998copy_stats_to_sc_xe201(POCE_SOFTC sc)
999{
1000 struct oce_xe201_stats *adapter_stats;
1001 struct mbx_get_pport_stats *nic_mbx;
1002 struct pport_stats *port_stats;
1003
1004 nic_mbx = OCE_DMAPTR(&sc->stats_mem, struct mbx_get_pport_stats);
1005 port_stats = &nic_mbx->params.rsp.pps;
1006 adapter_stats = &sc->oce_stats_info.u0.xe201;
1007
1008 adapter_stats->tx_pkts = port_stats->tx_pkts;
1009 adapter_stats->tx_unicast_pkts = port_stats->tx_unicast_pkts;
1010 adapter_stats->tx_multicast_pkts = port_stats->tx_multicast_pkts;
1011 adapter_stats->tx_broadcast_pkts = port_stats->tx_broadcast_pkts;
1012 adapter_stats->tx_bytes = port_stats->tx_bytes;
1013 adapter_stats->tx_unicast_bytes = port_stats->tx_unicast_bytes;
1014 adapter_stats->tx_multicast_bytes = port_stats->tx_multicast_bytes;
1015 adapter_stats->tx_broadcast_bytes = port_stats->tx_broadcast_bytes;
1016 adapter_stats->tx_discards = port_stats->tx_discards;
1017 adapter_stats->tx_errors = port_stats->tx_errors;
1018 adapter_stats->tx_pause_frames = port_stats->tx_pause_frames;
1019 adapter_stats->tx_pause_on_frames = port_stats->tx_pause_on_frames;
1020 adapter_stats->tx_pause_off_frames = port_stats->tx_pause_off_frames;
1021 adapter_stats->tx_internal_mac_errors =
1022 port_stats->tx_internal_mac_errors;
1023 adapter_stats->tx_control_frames = port_stats->tx_control_frames;
1024 adapter_stats->tx_pkts_64_bytes = port_stats->tx_pkts_64_bytes;
1025 adapter_stats->tx_pkts_65_to_127_bytes =
1026 port_stats->tx_pkts_65_to_127_bytes;
1027 adapter_stats->tx_pkts_128_to_255_bytes =
1028 port_stats->tx_pkts_128_to_255_bytes;
1029 adapter_stats->tx_pkts_256_to_511_bytes =
1030 port_stats->tx_pkts_256_to_511_bytes;
1031 adapter_stats->tx_pkts_512_to_1023_bytes =
1032 port_stats->tx_pkts_512_to_1023_bytes;
1033 adapter_stats->tx_pkts_1024_to_1518_bytes =
1034 port_stats->tx_pkts_1024_to_1518_bytes;
1035 adapter_stats->tx_pkts_1519_to_2047_bytes =
1036 port_stats->tx_pkts_1519_to_2047_bytes;
1037 adapter_stats->tx_pkts_2048_to_4095_bytes =
1038 port_stats->tx_pkts_2048_to_4095_bytes;
1039 adapter_stats->tx_pkts_4096_to_8191_bytes =
1040 port_stats->tx_pkts_4096_to_8191_bytes;
1041 adapter_stats->tx_pkts_8192_to_9216_bytes =
1042 port_stats->tx_pkts_8192_to_9216_bytes;
1043 adapter_stats->tx_lso_pkts = port_stats->tx_lso_pkts;
1044 adapter_stats->rx_pkts = port_stats->rx_pkts;
1045 adapter_stats->rx_unicast_pkts = port_stats->rx_unicast_pkts;
1046 adapter_stats->rx_multicast_pkts = port_stats->rx_multicast_pkts;
1047 adapter_stats->rx_broadcast_pkts = port_stats->rx_broadcast_pkts;
1048 adapter_stats->rx_bytes = port_stats->rx_bytes;
1049 adapter_stats->rx_unicast_bytes = port_stats->rx_unicast_bytes;
1050 adapter_stats->rx_multicast_bytes = port_stats->rx_multicast_bytes;
1051 adapter_stats->rx_broadcast_bytes = port_stats->rx_broadcast_bytes;
1052 adapter_stats->rx_unknown_protos = port_stats->rx_unknown_protos;
1053 adapter_stats->rx_discards = port_stats->rx_discards;
1054 adapter_stats->rx_errors = port_stats->rx_errors;
1055 adapter_stats->rx_crc_errors = port_stats->rx_crc_errors;
1056 adapter_stats->rx_alignment_errors = port_stats->rx_alignment_errors;
1057 adapter_stats->rx_symbol_errors = port_stats->rx_symbol_errors;
1058 adapter_stats->rx_pause_frames = port_stats->rx_pause_frames;
1059 adapter_stats->rx_pause_on_frames = port_stats->rx_pause_on_frames;
1060 adapter_stats->rx_pause_off_frames = port_stats->rx_pause_off_frames;
1061 adapter_stats->rx_frames_too_long = port_stats->rx_frames_too_long;
1062 adapter_stats->rx_internal_mac_errors =
1063 port_stats->rx_internal_mac_errors;
1064 adapter_stats->rx_undersize_pkts = port_stats->rx_undersize_pkts;
1065 adapter_stats->rx_oversize_pkts = port_stats->rx_oversize_pkts;
1066 adapter_stats->rx_fragment_pkts = port_stats->rx_fragment_pkts;
1067 adapter_stats->rx_jabbers = port_stats->rx_jabbers;
1068 adapter_stats->rx_control_frames = port_stats->rx_control_frames;
1069 adapter_stats->rx_control_frames_unknown_opcode =
1070 port_stats->rx_control_frames_unknown_opcode;
1071 adapter_stats->rx_in_range_errors = port_stats->rx_in_range_errors;
1072 adapter_stats->rx_out_of_range_errors =
1073 port_stats->rx_out_of_range_errors;
1074 adapter_stats->rx_address_match_errors =
1075 port_stats->rx_address_match_errors;
1076 adapter_stats->rx_vlan_mismatch_errors =
1077 port_stats->rx_vlan_mismatch_errors;
1078 adapter_stats->rx_dropped_too_small = port_stats->rx_dropped_too_small;
1079 adapter_stats->rx_dropped_too_short = port_stats->rx_dropped_too_short;
1080 adapter_stats->rx_dropped_header_too_small =
1081 port_stats->rx_dropped_header_too_small;
1082 adapter_stats->rx_dropped_invalid_tcp_length =
1083 port_stats->rx_dropped_invalid_tcp_length;
1084 adapter_stats->rx_dropped_runt = port_stats->rx_dropped_runt;
1085 adapter_stats->rx_ip_checksum_errors =
1086 port_stats->rx_ip_checksum_errors;
1087 adapter_stats->rx_tcp_checksum_errors =
1088 port_stats->rx_tcp_checksum_errors;
1089 adapter_stats->rx_udp_checksum_errors =
1090 port_stats->rx_udp_checksum_errors;
1091 adapter_stats->rx_non_rss_pkts = port_stats->rx_non_rss_pkts;
1092 adapter_stats->rx_ipv4_pkts = port_stats->rx_ipv4_pkts;
1093 adapter_stats->rx_ipv6_pkts = port_stats->rx_ipv6_pkts;
1094 adapter_stats->rx_ipv4_bytes = port_stats->rx_ipv4_bytes;
1095 adapter_stats->rx_ipv6_bytes = port_stats->rx_ipv6_bytes;
1096 adapter_stats->rx_nic_pkts = port_stats->rx_nic_pkts;
1097 adapter_stats->rx_tcp_pkts = port_stats->rx_tcp_pkts;
1098 adapter_stats->rx_iscsi_pkts = port_stats->rx_iscsi_pkts;
1099 adapter_stats->rx_management_pkts = port_stats->rx_management_pkts;
1100 adapter_stats->rx_switched_unicast_pkts =
1101 port_stats->rx_switched_unicast_pkts;
1102 adapter_stats->rx_switched_multicast_pkts =
1103 port_stats->rx_switched_multicast_pkts;
1104 adapter_stats->rx_switched_broadcast_pkts =
1105 port_stats->rx_switched_broadcast_pkts;
1106 adapter_stats->num_forwards = port_stats->num_forwards;
1107 adapter_stats->rx_fifo_overflow = port_stats->rx_fifo_overflow;
1108 adapter_stats->rx_input_fifo_overflow =
1109 port_stats->rx_input_fifo_overflow;
1110 adapter_stats->rx_drops_too_many_frags =
1111 port_stats->rx_drops_too_many_frags;
1112 adapter_stats->rx_drops_invalid_queue =
1113 port_stats->rx_drops_invalid_queue;
1114 adapter_stats->rx_drops_mtu = port_stats->rx_drops_mtu;
1115 adapter_stats->rx_pkts_64_bytes = port_stats->rx_pkts_64_bytes;
1116 adapter_stats->rx_pkts_65_to_127_bytes =
1117 port_stats->rx_pkts_65_to_127_bytes;
1118 adapter_stats->rx_pkts_128_to_255_bytes =
1119 port_stats->rx_pkts_128_to_255_bytes;
1120 adapter_stats->rx_pkts_256_to_511_bytes =
1121 port_stats->rx_pkts_256_to_511_bytes;
1122 adapter_stats->rx_pkts_512_to_1023_bytes =
1123 port_stats->rx_pkts_512_to_1023_bytes;
1124 adapter_stats->rx_pkts_1024_to_1518_bytes =
1125 port_stats->rx_pkts_1024_to_1518_bytes;
1126 adapter_stats->rx_pkts_1519_to_2047_bytes =
1127 port_stats->rx_pkts_1519_to_2047_bytes;
1128 adapter_stats->rx_pkts_2048_to_4095_bytes =
1129 port_stats->rx_pkts_2048_to_4095_bytes;
1130 adapter_stats->rx_pkts_4096_to_8191_bytes =
1131 port_stats->rx_pkts_4096_to_8191_bytes;
1132 adapter_stats->rx_pkts_8192_to_9216_bytes =
1133 port_stats->rx_pkts_8192_to_9216_bytes;
1134}
1135
1136
1137
1138static void
1139copy_stats_to_sc_be2(POCE_SOFTC sc)
1140{
1141 struct oce_be_stats *adapter_stats;
1142 struct oce_pmem_stats *pmem;
1143 struct oce_rxf_stats_v0 *rxf_stats;
1144 struct oce_port_rxf_stats_v0 *port_stats;
1145 struct mbx_get_nic_stats_v0 *nic_mbx;
1146 uint32_t port = sc->port_id;
1147
1148 nic_mbx = OCE_DMAPTR(&sc->stats_mem, struct mbx_get_nic_stats_v0);
1149 pmem = &nic_mbx->params.rsp.stats.pmem;
1150 rxf_stats = &nic_mbx->params.rsp.stats.rxf;
1151 port_stats = &nic_mbx->params.rsp.stats.rxf.port[port];
1152
1153 adapter_stats = &sc->oce_stats_info.u0.be;
1154
1155
1156 /* Update stats */
1157 adapter_stats->rx_pause_frames = port_stats->rx_pause_frames;
1158 adapter_stats->rx_crc_errors = port_stats->rx_crc_errors;
1159 adapter_stats->rx_control_frames = port_stats->rx_control_frames;
1160 adapter_stats->rx_in_range_errors = port_stats->rx_in_range_errors;
1161 adapter_stats->rx_frame_too_long = port_stats->rx_frame_too_long;
1162 adapter_stats->rx_dropped_runt = port_stats->rx_dropped_runt;
1163 adapter_stats->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
1164 adapter_stats->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
1165 adapter_stats->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
1166 adapter_stats->rxpp_fifo_overflow_drop =
1167 port_stats->rxpp_fifo_overflow_drop;
1168 adapter_stats->rx_dropped_tcp_length =
1169 port_stats->rx_dropped_tcp_length;
1170 adapter_stats->rx_dropped_too_small = port_stats->rx_dropped_too_small;
1171 adapter_stats->rx_dropped_too_short = port_stats->rx_dropped_too_short;
1172 adapter_stats->rx_out_range_errors = port_stats->rx_out_range_errors;
1173 adapter_stats->rx_dropped_header_too_small =
1174 port_stats->rx_dropped_header_too_small;
1175 adapter_stats->rx_input_fifo_overflow_drop =
1176 port_stats->rx_input_fifo_overflow_drop;
1177 adapter_stats->rx_address_match_errors =
1178 port_stats->rx_address_match_errors;
1179 adapter_stats->rx_alignment_symbol_errors =
1180 port_stats->rx_alignment_symbol_errors;
1181 adapter_stats->tx_pauseframes = port_stats->tx_pauseframes;
1182 adapter_stats->tx_controlframes = port_stats->tx_controlframes;
1183
1184 if (sc->if_id)
1185 adapter_stats->jabber_events = rxf_stats->port1_jabber_events;
1186 else
1187 adapter_stats->jabber_events = rxf_stats->port0_jabber_events;
1188
1189 adapter_stats->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
1190 adapter_stats->rx_drops_no_txpb = rxf_stats->rx_drops_no_txpb;
1191 adapter_stats->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
1192 adapter_stats->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring;
1193 adapter_stats->forwarded_packets = rxf_stats->forwarded_packets;
1194 adapter_stats->rx_drops_mtu = rxf_stats->rx_drops_mtu;
1195 adapter_stats->rx_drops_no_tpre_descr =
1196 rxf_stats->rx_drops_no_tpre_descr;
1197 adapter_stats->rx_drops_too_many_frags =
1198 rxf_stats->rx_drops_too_many_frags;
1199 adapter_stats->eth_red_drops = pmem->eth_red_drops;
1200}
1201
1202
1203static void
1204copy_stats_to_sc_be3(POCE_SOFTC sc)
1205{
1206 struct oce_be_stats *adapter_stats;
1207 struct oce_pmem_stats *pmem;
1208 struct oce_rxf_stats_v1 *rxf_stats;
1209 struct oce_port_rxf_stats_v1 *port_stats;
1210 struct mbx_get_nic_stats *nic_mbx;
1211 uint32_t port = sc->port_id;
1212
1213 nic_mbx = OCE_DMAPTR(&sc->stats_mem, struct mbx_get_nic_stats);
1214 pmem = &nic_mbx->params.rsp.stats.pmem;
1215 rxf_stats = &nic_mbx->params.rsp.stats.rxf;
1216 port_stats = &nic_mbx->params.rsp.stats.rxf.port[port];
1217
1218 adapter_stats = &sc->oce_stats_info.u0.be;
1219
1220 /* Update stats */
1221 adapter_stats->pmem_fifo_overflow_drop =
1222 port_stats->pmem_fifo_overflow_drop;
1223 adapter_stats->rx_priority_pause_frames =
1224 port_stats->rx_priority_pause_frames;
1225 adapter_stats->rx_pause_frames = port_stats->rx_pause_frames;
1226 adapter_stats->rx_crc_errors = port_stats->rx_crc_errors;
1227 adapter_stats->rx_control_frames = port_stats->rx_control_frames;
1228 adapter_stats->rx_in_range_errors = port_stats->rx_in_range_errors;
1229 adapter_stats->rx_frame_too_long = port_stats->rx_frame_too_long;
1230 adapter_stats->rx_dropped_runt = port_stats->rx_dropped_runt;
1231 adapter_stats->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
1232 adapter_stats->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
1233 adapter_stats->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
1234 adapter_stats->rx_dropped_tcp_length =
1235 port_stats->rx_dropped_tcp_length;
1236 adapter_stats->rx_dropped_too_small = port_stats->rx_dropped_too_small;
1237 adapter_stats->rx_dropped_too_short = port_stats->rx_dropped_too_short;
1238 adapter_stats->rx_out_range_errors = port_stats->rx_out_range_errors;
1239 adapter_stats->rx_dropped_header_too_small =
1240 port_stats->rx_dropped_header_too_small;
1241 adapter_stats->rx_input_fifo_overflow_drop =
1242 port_stats->rx_input_fifo_overflow_drop;
1243 adapter_stats->rx_address_match_errors =
1244 port_stats->rx_address_match_errors;
1245 adapter_stats->rx_alignment_symbol_errors =
1246 port_stats->rx_alignment_symbol_errors;
1247 adapter_stats->rxpp_fifo_overflow_drop =
1248 port_stats->rxpp_fifo_overflow_drop;
1249 adapter_stats->tx_pauseframes = port_stats->tx_pauseframes;
1250 adapter_stats->tx_controlframes = port_stats->tx_controlframes;
1251 adapter_stats->jabber_events = port_stats->jabber_events;
1252
1253 adapter_stats->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
1254 adapter_stats->rx_drops_no_txpb = rxf_stats->rx_drops_no_txpb;
1255 adapter_stats->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
1256 adapter_stats->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring;
1257 adapter_stats->forwarded_packets = rxf_stats->forwarded_packets;
1258 adapter_stats->rx_drops_mtu = rxf_stats->rx_drops_mtu;
1259 adapter_stats->rx_drops_no_tpre_descr =
1260 rxf_stats->rx_drops_no_tpre_descr;
1261 adapter_stats->rx_drops_too_many_frags =
1262 rxf_stats->rx_drops_too_many_frags;
1263
1264 adapter_stats->eth_red_drops = pmem->eth_red_drops;
1265}
1266
1267
1268int
1269oce_stats_init(POCE_SOFTC sc)
1270{
1271 int rc = 0, sz;
1272
1273 if (IS_BE(sc) || IS_SH(sc)) {
1274 if (sc->flags & OCE_FLAGS_BE2)
1275 sz = sizeof(struct mbx_get_nic_stats_v0);
1276 else
1277 sz = sizeof(struct mbx_get_nic_stats);
1278 } else
1279 sz = sizeof(struct mbx_get_pport_stats);
1280
1281 rc = oce_dma_alloc(sc, sz, &sc->stats_mem, 0);
1282
1283 return rc;
1284}
1285
1286
1287void
1288oce_stats_free(POCE_SOFTC sc)
1289{
1290
1291 oce_dma_free(sc, &sc->stats_mem);
1292
1293}
1294
1295
1296int
1297oce_refresh_nic_stats(POCE_SOFTC sc)
1298{
1299 int rc = 0, reset = 0;
1300
1301 if (IS_BE(sc) || IS_SH(sc)) {
1302 if (sc->flags & OCE_FLAGS_BE2) {
1303 rc = oce_mbox_get_nic_stats_v0(sc, &sc->stats_mem);
1304 if (!rc)
1305 copy_stats_to_sc_be2(sc);
1306 } else {
1307 rc = oce_mbox_get_nic_stats(sc, &sc->stats_mem);
1308 if (!rc)
1309 copy_stats_to_sc_be3(sc);
1310 }
1311
1312 } else {
1313 rc = oce_mbox_get_pport_stats(sc, &sc->stats_mem, reset);
1314 if (!rc)
1315 copy_stats_to_sc_xe201(sc);
1316 }
1317
1318 return rc;
1319}
1320
1321static int
1322oce_sysctl_sfp_vpd_dump(SYSCTL_HANDLER_ARGS)
1323{
1324 int result = 0, error;
1325 int rc = 0;
1326 POCE_SOFTC sc = (POCE_SOFTC) arg1;
1327
1328 /* sysctl default handler */
1329 error = sysctl_handle_int(oidp, &result, 0, req);
1330 if (error || !req->newptr)
1331 return (error);
1332
1333 if(result == -1) {
1334 return EINVAL;
1335 }
1336 bzero((char *)sfp_vpd_dump_buffer, TRANSCEIVER_DATA_SIZE);
1337
1338 rc = oce_mbox_read_transrecv_data(sc, PAGE_NUM_A0);
1339 if(rc)
1340 return rc;
1341
1342 rc = oce_mbox_read_transrecv_data(sc, PAGE_NUM_A2);
1343 if(rc)
1344 return rc;
1345
1346 return rc;
1347}
561static boolean_t
562oce_phy_flashing_required(POCE_SOFTC sc)
563{
564 int status = 0;
565 struct oce_phy_info phy_info;
566
567 status = oce_mbox_get_phy_info(sc, &phy_info);
568 if (status)
569 return FALSE;
570
571 if ((phy_info.phy_type == TN_8022) &&
572 (phy_info.interface_type == PHY_TYPE_BASET_10GB)) {
573 return TRUE;
574 }
575
576 return FALSE;
577}
578
579
580static boolean_t
581oce_img_flashing_required(POCE_SOFTC sc, const char *p,
582 int img_optype, uint32_t img_offset,
583 uint32_t img_size, uint32_t hdrs_size)
584{
585 uint32_t crc_offset;
586 uint8_t flashed_crc[4];
587 int status;
588
589 crc_offset = hdrs_size + img_offset + img_size - 4;
590
591 p += crc_offset;
592
593 status = oce_mbox_get_flashrom_crc(sc, flashed_crc,
594 (img_size - 4), img_optype);
595 if (status)
596 return TRUE; /* Some thing worng. ReFlash */
597
598 /*update redboot only if crc does not match*/
599 if (bcmp(flashed_crc, p, 4))
600 return TRUE;
601 else
602 return FALSE;
603}
604
605
606static int
607oce_lancer_fwupgrade(POCE_SOFTC sc, const struct firmware *fw)
608{
609
610 int rc = 0;
611 OCE_DMA_MEM dma_mem;
612 const uint8_t *data = NULL;
613 uint8_t *dest_image_ptr = NULL;
614 size_t size = 0;
615 uint32_t data_written = 0, chunk_size = 0;
616 uint32_t offset = 0, add_status = 0;
617
618 if (!IS_ALIGNED(fw->datasize, sizeof(uint32_t))) {
619 device_printf(sc->dev,
620 "Lancer FW image is not 4 byte aligned.");
621 return EINVAL;
622 }
623
624 rc = oce_dma_alloc(sc, 32*1024, &dma_mem, 0);
625 if (rc) {
626 device_printf(sc->dev,
627 "Memory allocation failure while flashing Lancer\n");
628 return ENOMEM;
629 }
630
631 size = fw->datasize;
632 data = fw->data;
633 dest_image_ptr = OCE_DMAPTR(&dma_mem, uint8_t);
634
635 while (size) {
636 chunk_size = MIN(size, (32*1024));
637
638 bcopy(data, dest_image_ptr, chunk_size);
639
640 rc = oce_mbox_lancer_write_flashrom(sc, chunk_size, offset,
641 &dma_mem, &data_written, &add_status);
642
643 if (rc)
644 break;
645
646 size -= data_written;
647 data += data_written;
648 offset += data_written;
649 pause("yield", 10);
650
651 }
652
653 if (!rc)
654 /* Commit the firmware*/
655 rc = oce_mbox_lancer_write_flashrom(sc, 0, offset, &dma_mem,
656 &data_written, &add_status);
657 if (rc) {
658 device_printf(sc->dev, "Lancer firmware load error. "
659 "Addstatus = 0x%x, status = %d \n", add_status, rc);
660 rc = EIO;
661 }
662 oce_dma_free(sc, &dma_mem);
663 return rc;
664
665}
666
667
668static void
669oce_add_stats_sysctls_be3(POCE_SOFTC sc,
670 struct sysctl_ctx_list *ctx,
671 struct sysctl_oid *stats_node)
672{
673 struct sysctl_oid *rx_stats_node, *tx_stats_node;
674 struct sysctl_oid_list *rx_stat_list, *tx_stat_list;
675 struct sysctl_oid_list *queue_stats_list;
676 struct sysctl_oid *queue_stats_node;
677 struct oce_drv_stats *stats;
678 char prefix[32];
679 int i;
680
681 stats = &sc->oce_stats_info;
682
683 rx_stats_node = SYSCTL_ADD_NODE(ctx,
684 SYSCTL_CHILDREN(stats_node),
685 OID_AUTO,"rx", CTLFLAG_RD,
686 NULL, "RX Ethernet Statistics");
687 rx_stat_list = SYSCTL_CHILDREN(rx_stats_node);
688
689
690 SYSCTL_ADD_QUAD(ctx, rx_stat_list, OID_AUTO, "total_pkts",
691 CTLFLAG_RD, &stats->rx.t_rx_pkts,
692 "Total Received Packets");
693 SYSCTL_ADD_QUAD(ctx, rx_stat_list, OID_AUTO, "total_bytes",
694 CTLFLAG_RD, &stats->rx.t_rx_bytes,
695 "Total Received Bytes");
696 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_frags",
697 CTLFLAG_RD, &stats->rx.t_rx_frags, 0,
698 "Total Received Fragements");
699 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_mcast_pkts",
700 CTLFLAG_RD, &stats->rx.t_rx_mcast_pkts, 0,
701 "Total Received Multicast Packets");
702 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_ucast_pkts",
703 CTLFLAG_RD, &stats->rx.t_rx_ucast_pkts, 0,
704 "Total Received Unicast Packets");
705 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_rxcp_errs",
706 CTLFLAG_RD, &stats->rx.t_rxcp_errs, 0,
707 "Total Receive completion errors");
708 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "pause_frames",
709 CTLFLAG_RD, &stats->u0.be.rx_pause_frames, 0,
710 "Pause Frames");
711 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "priority_pause_frames",
712 CTLFLAG_RD, &stats->u0.be.rx_priority_pause_frames, 0,
713 "Priority Pause Frames");
714 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "control_frames",
715 CTLFLAG_RD, &stats->u0.be.rx_control_frames, 0,
716 "Control Frames");
717
718 for (i = 0; i < sc->nrqs; i++) {
719 sprintf(prefix, "queue%d",i);
720 queue_stats_node = SYSCTL_ADD_NODE(ctx,
721 SYSCTL_CHILDREN(rx_stats_node),
722 OID_AUTO, prefix, CTLFLAG_RD,
723 NULL, "Queue name");
724 queue_stats_list = SYSCTL_CHILDREN(queue_stats_node);
725
726 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "rx_pkts",
727 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_pkts,
728 "Receive Packets");
729 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "rx_bytes",
730 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_bytes,
731 "Recived Bytes");
732 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "rx_frags",
733 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_frags, 0,
734 "Received Fragments");
735 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO,
736 "rx_mcast_pkts", CTLFLAG_RD,
737 &sc->rq[i]->rx_stats.rx_mcast_pkts, 0,
738 "Received Multicast Packets");
739 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO,
740 "rx_ucast_pkts", CTLFLAG_RD,
741 &sc->rq[i]->rx_stats.rx_ucast_pkts, 0,
742 "Received Unicast Packets");
743 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "rxcp_err",
744 CTLFLAG_RD, &sc->rq[i]->rx_stats.rxcp_err, 0,
745 "Received Completion Errors");
746
747 }
748
749 rx_stats_node = SYSCTL_ADD_NODE(ctx,
750 SYSCTL_CHILDREN(rx_stats_node),
751 OID_AUTO, "err", CTLFLAG_RD,
752 NULL, "Receive Error Stats");
753 rx_stat_list = SYSCTL_CHILDREN(rx_stats_node);
754
755 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "crc_errs",
756 CTLFLAG_RD, &stats->u0.be.rx_crc_errors, 0,
757 "CRC Errors");
758 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "pbuf_errors",
759 CTLFLAG_RD, &stats->u0.be.rx_drops_no_pbuf, 0,
760 "Drops due to pbuf full");
761 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "erx_errors",
762 CTLFLAG_RD, &stats->u0.be.rx_drops_no_erx_descr, 0,
763 "ERX Errors");
764 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "alignment_errors",
765 CTLFLAG_RD, &stats->u0.be.rx_drops_too_many_frags, 0,
766 "RX Alignmnet Errors");
767 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "in_range_errors",
768 CTLFLAG_RD, &stats->u0.be.rx_in_range_errors, 0,
769 "In Range Errors");
770 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "out_range_errors",
771 CTLFLAG_RD, &stats->u0.be.rx_out_range_errors, 0,
772 "Out Range Errors");
773 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "frame_too_long",
774 CTLFLAG_RD, &stats->u0.be.rx_frame_too_long, 0,
775 "Frame Too Long");
776 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "address_match_errors",
777 CTLFLAG_RD, &stats->u0.be.rx_address_match_errors, 0,
778 "Address Match Errors");
779 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_too_small",
780 CTLFLAG_RD, &stats->u0.be.rx_dropped_too_small, 0,
781 "Dropped Too Small");
782 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_too_short",
783 CTLFLAG_RD, &stats->u0.be.rx_dropped_too_short, 0,
784 "Dropped Too Short");
785 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO,
786 "dropped_header_too_small", CTLFLAG_RD,
787 &stats->u0.be.rx_dropped_header_too_small, 0,
788 "Dropped Header Too Small");
789 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_tcp_length",
790 CTLFLAG_RD, &stats->u0.be.rx_dropped_tcp_length, 0,
791 "Dropped TCP Length");
792 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_runt",
793 CTLFLAG_RD, &stats->u0.be.rx_dropped_runt, 0,
794 "Dropped runt");
795 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "ip_checksum_errs",
796 CTLFLAG_RD, &stats->u0.be.rx_ip_checksum_errs, 0,
797 "IP Checksum Errors");
798 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "tcp_checksum_errs",
799 CTLFLAG_RD, &stats->u0.be.rx_tcp_checksum_errs, 0,
800 "TCP Checksum Errors");
801 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "udp_checksum_errs",
802 CTLFLAG_RD, &stats->u0.be.rx_udp_checksum_errs, 0,
803 "UDP Checksum Errors");
804 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "fifo_overflow_drop",
805 CTLFLAG_RD, &stats->u0.be.rxpp_fifo_overflow_drop, 0,
806 "FIFO Overflow Drop");
807 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO,
808 "input_fifo_overflow_drop", CTLFLAG_RD,
809 &stats->u0.be.rx_input_fifo_overflow_drop, 0,
810 "Input FIFO Overflow Drop");
811
812 tx_stats_node = SYSCTL_ADD_NODE(ctx,
813 SYSCTL_CHILDREN(stats_node), OID_AUTO,
814 "tx",CTLFLAG_RD, NULL,
815 "TX Ethernet Statistics");
816 tx_stat_list = SYSCTL_CHILDREN(tx_stats_node);
817
818 SYSCTL_ADD_QUAD(ctx, tx_stat_list, OID_AUTO, "total_tx_pkts",
819 CTLFLAG_RD, &stats->tx.t_tx_pkts,
820 "Total Transmit Packets");
821 SYSCTL_ADD_QUAD(ctx, tx_stat_list, OID_AUTO, "total_tx_bytes",
822 CTLFLAG_RD, &stats->tx.t_tx_bytes,
823 "Total Transmit Bytes");
824 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_reqs",
825 CTLFLAG_RD, &stats->tx.t_tx_reqs, 0,
826 "Total Transmit Requests");
827 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_stops",
828 CTLFLAG_RD, &stats->tx.t_tx_stops, 0,
829 "Total Transmit Stops");
830 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_wrbs",
831 CTLFLAG_RD, &stats->tx.t_tx_wrbs, 0,
832 "Total Transmit WRB's");
833 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_compl",
834 CTLFLAG_RD, &stats->tx.t_tx_compl, 0,
835 "Total Transmit Completions");
836 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO,
837 "total_ipv6_ext_hdr_tx_drop", CTLFLAG_RD,
838 &stats->tx.t_ipv6_ext_hdr_tx_drop, 0,
839 "Total Transmit IPV6 Drops");
840 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "pauseframes",
841 CTLFLAG_RD, &stats->u0.be.tx_pauseframes, 0,
842 "Pause Frames");
843 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "priority_pauseframes",
844 CTLFLAG_RD, &stats->u0.be.tx_priority_pauseframes, 0,
845 "Priority Pauseframes");
846 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "controlframes",
847 CTLFLAG_RD, &stats->u0.be.tx_controlframes, 0,
848 "Tx Control Frames");
849
850 for (i = 0; i < sc->nwqs; i++) {
851 sprintf(prefix, "queue%d",i);
852 queue_stats_node = SYSCTL_ADD_NODE(ctx,
853 SYSCTL_CHILDREN(tx_stats_node),
854 OID_AUTO, prefix, CTLFLAG_RD,
855 NULL, "Queue name");
856 queue_stats_list = SYSCTL_CHILDREN(queue_stats_node);
857
858 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "tx_pkts",
859 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_pkts,
860 "Transmit Packets");
861 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "tx_bytes",
862 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_bytes,
863 "Transmit Bytes");
864 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_reqs",
865 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_reqs, 0,
866 "Transmit Requests");
867 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_stops",
868 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_stops, 0,
869 "Transmit Stops");
870 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_wrbs",
871 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_wrbs, 0,
872 "Transmit WRB's");
873 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_compl",
874 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_compl, 0,
875 "Transmit Completions");
876 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO,
877 "ipv6_ext_hdr_tx_drop",CTLFLAG_RD,
878 &sc->wq[i]->tx_stats.ipv6_ext_hdr_tx_drop, 0,
879 "Transmit IPV6 Ext Header Drop");
880
881 }
882 return;
883}
884
885
886static void
887oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
888 struct sysctl_ctx_list *ctx,
889 struct sysctl_oid *stats_node)
890{
891 struct sysctl_oid *rx_stats_node, *tx_stats_node;
892 struct sysctl_oid_list *rx_stat_list, *tx_stat_list;
893 struct sysctl_oid_list *queue_stats_list;
894 struct sysctl_oid *queue_stats_node;
895 struct oce_drv_stats *stats;
896 char prefix[32];
897 int i;
898
899 stats = &sc->oce_stats_info;
900
901 rx_stats_node = SYSCTL_ADD_NODE(ctx,
902 SYSCTL_CHILDREN(stats_node),
903 OID_AUTO, "rx", CTLFLAG_RD,
904 NULL, "RX Ethernet Statistics");
905 rx_stat_list = SYSCTL_CHILDREN(rx_stats_node);
906
907
908 SYSCTL_ADD_QUAD(ctx, rx_stat_list, OID_AUTO, "total_pkts",
909 CTLFLAG_RD, &stats->rx.t_rx_pkts,
910 "Total Received Packets");
911 SYSCTL_ADD_QUAD(ctx, rx_stat_list, OID_AUTO, "total_bytes",
912 CTLFLAG_RD, &stats->rx.t_rx_bytes,
913 "Total Received Bytes");
914 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_frags",
915 CTLFLAG_RD, &stats->rx.t_rx_frags, 0,
916 "Total Received Fragements");
917 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_mcast_pkts",
918 CTLFLAG_RD, &stats->rx.t_rx_mcast_pkts, 0,
919 "Total Received Multicast Packets");
920 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_ucast_pkts",
921 CTLFLAG_RD, &stats->rx.t_rx_ucast_pkts, 0,
922 "Total Received Unicast Packets");
923 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_rxcp_errs",
924 CTLFLAG_RD, &stats->rx.t_rxcp_errs, 0,
925 "Total Receive completion errors");
926 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "pause_frames",
927 CTLFLAG_RD, &stats->u0.xe201.rx_pause_frames, 0,
928 "Pause Frames");
929 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "control_frames",
930 CTLFLAG_RD, &stats->u0.xe201.rx_control_frames, 0,
931 "Control Frames");
932
933 for (i = 0; i < sc->nrqs; i++) {
934 sprintf(prefix, "queue%d",i);
935 queue_stats_node = SYSCTL_ADD_NODE(ctx,
936 SYSCTL_CHILDREN(rx_stats_node),
937 OID_AUTO, prefix, CTLFLAG_RD,
938 NULL, "Queue name");
939 queue_stats_list = SYSCTL_CHILDREN(queue_stats_node);
940
941 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "rx_pkts",
942 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_pkts,
943 "Receive Packets");
944 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "rx_bytes",
945 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_bytes,
946 "Recived Bytes");
947 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "rx_frags",
948 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_frags, 0,
949 "Received Fragments");
950 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO,
951 "rx_mcast_pkts", CTLFLAG_RD,
952 &sc->rq[i]->rx_stats.rx_mcast_pkts, 0,
953 "Received Multicast Packets");
954 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO,
955 "rx_ucast_pkts",CTLFLAG_RD,
956 &sc->rq[i]->rx_stats.rx_ucast_pkts, 0,
957 "Received Unicast Packets");
958 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "rxcp_err",
959 CTLFLAG_RD, &sc->rq[i]->rx_stats.rxcp_err, 0,
960 "Received Completion Errors");
961
962 }
963
964 rx_stats_node = SYSCTL_ADD_NODE(ctx,
965 SYSCTL_CHILDREN(rx_stats_node),
966 OID_AUTO, "err", CTLFLAG_RD,
967 NULL, "Receive Error Stats");
968 rx_stat_list = SYSCTL_CHILDREN(rx_stats_node);
969
970 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "crc_errs",
971 CTLFLAG_RD, &stats->u0.xe201.rx_crc_errors, 0,
972 "CRC Errors");
973 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "alignment_errors",
974 CTLFLAG_RD, &stats->u0.xe201.rx_alignment_errors, 0,
975 "RX Alignmnet Errors");
976 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "in_range_errors",
977 CTLFLAG_RD, &stats->u0.xe201.rx_in_range_errors, 0,
978 "In Range Errors");
979 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "out_range_errors",
980 CTLFLAG_RD, &stats->u0.xe201.rx_out_of_range_errors, 0,
981 "Out Range Errors");
982 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "frame_too_long",
983 CTLFLAG_RD, &stats->u0.xe201.rx_frames_too_long, 0,
984 "Frame Too Long");
985 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "address_match_errors",
986 CTLFLAG_RD, &stats->u0.xe201.rx_address_match_errors, 0,
987 "Address Match Errors");
988 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_too_small",
989 CTLFLAG_RD, &stats->u0.xe201.rx_dropped_too_small, 0,
990 "Dropped Too Small");
991 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_too_short",
992 CTLFLAG_RD, &stats->u0.xe201.rx_dropped_too_short, 0,
993 "Dropped Too Short");
994 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO,
995 "dropped_header_too_small", CTLFLAG_RD,
996 &stats->u0.xe201.rx_dropped_header_too_small, 0,
997 "Dropped Header Too Small");
998 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO,
999 "dropped_tcp_length", CTLFLAG_RD,
1000 &stats->u0.xe201.rx_dropped_invalid_tcp_length, 0,
1001 "Dropped TCP Length");
1002 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_runt",
1003 CTLFLAG_RD, &stats->u0.xe201.rx_dropped_runt, 0,
1004 "Dropped runt");
1005 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "ip_checksum_errs",
1006 CTLFLAG_RD, &stats->u0.xe201.rx_ip_checksum_errors, 0,
1007 "IP Checksum Errors");
1008 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "tcp_checksum_errs",
1009 CTLFLAG_RD, &stats->u0.xe201.rx_tcp_checksum_errors, 0,
1010 "TCP Checksum Errors");
1011 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "udp_checksum_errs",
1012 CTLFLAG_RD, &stats->u0.xe201.rx_udp_checksum_errors, 0,
1013 "UDP Checksum Errors");
1014 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "input_fifo_overflow_drop",
1015 CTLFLAG_RD, &stats->u0.xe201.rx_fifo_overflow, 0,
1016 "Input FIFO Overflow Drop");
1017
1018 tx_stats_node = SYSCTL_ADD_NODE(ctx,
1019 SYSCTL_CHILDREN(stats_node),
1020 OID_AUTO, "tx", CTLFLAG_RD,
1021 NULL, "TX Ethernet Statistics");
1022 tx_stat_list = SYSCTL_CHILDREN(tx_stats_node);
1023
1024 SYSCTL_ADD_QUAD(ctx, tx_stat_list, OID_AUTO, "total_tx_pkts",
1025 CTLFLAG_RD, &stats->tx.t_tx_pkts,
1026 "Total Transmit Packets");
1027 SYSCTL_ADD_QUAD(ctx, tx_stat_list, OID_AUTO, "total_tx_bytes",
1028 CTLFLAG_RD, &stats->tx.t_tx_bytes,
1029 "Total Transmit Bytes");
1030 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_reqs",
1031 CTLFLAG_RD, &stats->tx.t_tx_reqs, 0,
1032 "Total Transmit Requests");
1033 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_stops",
1034 CTLFLAG_RD, &stats->tx.t_tx_stops, 0,
1035 "Total Transmit Stops");
1036 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_wrbs",
1037 CTLFLAG_RD, &stats->tx.t_tx_wrbs, 0,
1038 "Total Transmit WRB's");
1039 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_compl",
1040 CTLFLAG_RD, &stats->tx.t_tx_compl, 0,
1041 "Total Transmit Completions");
1042 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO,
1043 "total_ipv6_ext_hdr_tx_drop",
1044 CTLFLAG_RD, &stats->tx.t_ipv6_ext_hdr_tx_drop, 0,
1045 "Total Transmit IPV6 Drops");
1046 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "pauseframes",
1047 CTLFLAG_RD, &stats->u0.xe201.tx_pause_frames, 0,
1048 "Pause Frames");
1049 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "controlframes",
1050 CTLFLAG_RD, &stats->u0.xe201.tx_control_frames, 0,
1051 "Tx Control Frames");
1052
1053 for (i = 0; i < sc->nwqs; i++) {
1054 sprintf(prefix, "queue%d",i);
1055 queue_stats_node = SYSCTL_ADD_NODE(ctx,
1056 SYSCTL_CHILDREN(tx_stats_node),
1057 OID_AUTO, prefix, CTLFLAG_RD,
1058 NULL, "Queue name");
1059 queue_stats_list = SYSCTL_CHILDREN(queue_stats_node);
1060
1061 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "tx_pkts",
1062 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_pkts,
1063 "Transmit Packets");
1064 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "tx_bytes",
1065 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_bytes,
1066 "Transmit Bytes");
1067 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_reqs",
1068 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_reqs, 0,
1069 "Transmit Requests");
1070 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_stops",
1071 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_stops, 0,
1072 "Transmit Stops");
1073 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_wrbs",
1074 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_wrbs, 0,
1075 "Transmit WRB's");
1076 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_compl",
1077 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_compl, 0,
1078 "Transmit Completions");
1079 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO,
1080 "ipv6_ext_hdr_tx_drop", CTLFLAG_RD,
1081 &sc->wq[i]->tx_stats.ipv6_ext_hdr_tx_drop, 0,
1082 "Transmit IPV6 Ext Header Drop");
1083
1084 }
1085 return;
1086}
1087
1088
1089void
1090oce_refresh_queue_stats(POCE_SOFTC sc)
1091{
1092 struct oce_drv_stats *adapter_stats;
1093 int i;
1094
1095 adapter_stats = &sc->oce_stats_info;
1096
1097 /* Caluculate total TX and TXstats from all queues */
1098
1099 bzero(&adapter_stats->rx, sizeof(struct oce_rx_stats));
1100 for (i = 0; i < sc->nrqs; i++) {
1101
1102 adapter_stats->rx.t_rx_pkts += sc->rq[i]->rx_stats.rx_pkts;
1103 adapter_stats->rx.t_rx_bytes += sc->rq[i]->rx_stats.rx_bytes;
1104 adapter_stats->rx.t_rx_frags += sc->rq[i]->rx_stats.rx_frags;
1105 adapter_stats->rx.t_rx_mcast_pkts +=
1106 sc->rq[i]->rx_stats.rx_mcast_pkts;
1107 adapter_stats->rx.t_rx_ucast_pkts +=
1108 sc->rq[i]->rx_stats.rx_ucast_pkts;
1109 adapter_stats->rx.t_rxcp_errs += sc-> rq[i]->rx_stats.rxcp_err;
1110 }
1111
1112 bzero(&adapter_stats->tx, sizeof(struct oce_tx_stats));
1113 for (i = 0; i < sc->nwqs; i++) {
1114 adapter_stats->tx.t_tx_reqs += sc->wq[i]->tx_stats.tx_reqs;
1115 adapter_stats->tx.t_tx_stops += sc->wq[i]->tx_stats.tx_stops;
1116 adapter_stats->tx.t_tx_wrbs += sc->wq[i]->tx_stats.tx_wrbs;
1117 adapter_stats->tx.t_tx_compl += sc->wq[i]->tx_stats.tx_compl;
1118 adapter_stats->tx.t_tx_bytes += sc->wq[i]->tx_stats.tx_bytes;
1119 adapter_stats->tx.t_tx_pkts += sc->wq[i]->tx_stats.tx_pkts;
1120 adapter_stats->tx.t_ipv6_ext_hdr_tx_drop +=
1121 sc->wq[i]->tx_stats.ipv6_ext_hdr_tx_drop;
1122 }
1123
1124}
1125
1126
1127
1128static void
1129copy_stats_to_sc_xe201(POCE_SOFTC sc)
1130{
1131 struct oce_xe201_stats *adapter_stats;
1132 struct mbx_get_pport_stats *nic_mbx;
1133 struct pport_stats *port_stats;
1134
1135 nic_mbx = OCE_DMAPTR(&sc->stats_mem, struct mbx_get_pport_stats);
1136 port_stats = &nic_mbx->params.rsp.pps;
1137 adapter_stats = &sc->oce_stats_info.u0.xe201;
1138
1139 adapter_stats->tx_pkts = port_stats->tx_pkts;
1140 adapter_stats->tx_unicast_pkts = port_stats->tx_unicast_pkts;
1141 adapter_stats->tx_multicast_pkts = port_stats->tx_multicast_pkts;
1142 adapter_stats->tx_broadcast_pkts = port_stats->tx_broadcast_pkts;
1143 adapter_stats->tx_bytes = port_stats->tx_bytes;
1144 adapter_stats->tx_unicast_bytes = port_stats->tx_unicast_bytes;
1145 adapter_stats->tx_multicast_bytes = port_stats->tx_multicast_bytes;
1146 adapter_stats->tx_broadcast_bytes = port_stats->tx_broadcast_bytes;
1147 adapter_stats->tx_discards = port_stats->tx_discards;
1148 adapter_stats->tx_errors = port_stats->tx_errors;
1149 adapter_stats->tx_pause_frames = port_stats->tx_pause_frames;
1150 adapter_stats->tx_pause_on_frames = port_stats->tx_pause_on_frames;
1151 adapter_stats->tx_pause_off_frames = port_stats->tx_pause_off_frames;
1152 adapter_stats->tx_internal_mac_errors =
1153 port_stats->tx_internal_mac_errors;
1154 adapter_stats->tx_control_frames = port_stats->tx_control_frames;
1155 adapter_stats->tx_pkts_64_bytes = port_stats->tx_pkts_64_bytes;
1156 adapter_stats->tx_pkts_65_to_127_bytes =
1157 port_stats->tx_pkts_65_to_127_bytes;
1158 adapter_stats->tx_pkts_128_to_255_bytes =
1159 port_stats->tx_pkts_128_to_255_bytes;
1160 adapter_stats->tx_pkts_256_to_511_bytes =
1161 port_stats->tx_pkts_256_to_511_bytes;
1162 adapter_stats->tx_pkts_512_to_1023_bytes =
1163 port_stats->tx_pkts_512_to_1023_bytes;
1164 adapter_stats->tx_pkts_1024_to_1518_bytes =
1165 port_stats->tx_pkts_1024_to_1518_bytes;
1166 adapter_stats->tx_pkts_1519_to_2047_bytes =
1167 port_stats->tx_pkts_1519_to_2047_bytes;
1168 adapter_stats->tx_pkts_2048_to_4095_bytes =
1169 port_stats->tx_pkts_2048_to_4095_bytes;
1170 adapter_stats->tx_pkts_4096_to_8191_bytes =
1171 port_stats->tx_pkts_4096_to_8191_bytes;
1172 adapter_stats->tx_pkts_8192_to_9216_bytes =
1173 port_stats->tx_pkts_8192_to_9216_bytes;
1174 adapter_stats->tx_lso_pkts = port_stats->tx_lso_pkts;
1175 adapter_stats->rx_pkts = port_stats->rx_pkts;
1176 adapter_stats->rx_unicast_pkts = port_stats->rx_unicast_pkts;
1177 adapter_stats->rx_multicast_pkts = port_stats->rx_multicast_pkts;
1178 adapter_stats->rx_broadcast_pkts = port_stats->rx_broadcast_pkts;
1179 adapter_stats->rx_bytes = port_stats->rx_bytes;
1180 adapter_stats->rx_unicast_bytes = port_stats->rx_unicast_bytes;
1181 adapter_stats->rx_multicast_bytes = port_stats->rx_multicast_bytes;
1182 adapter_stats->rx_broadcast_bytes = port_stats->rx_broadcast_bytes;
1183 adapter_stats->rx_unknown_protos = port_stats->rx_unknown_protos;
1184 adapter_stats->rx_discards = port_stats->rx_discards;
1185 adapter_stats->rx_errors = port_stats->rx_errors;
1186 adapter_stats->rx_crc_errors = port_stats->rx_crc_errors;
1187 adapter_stats->rx_alignment_errors = port_stats->rx_alignment_errors;
1188 adapter_stats->rx_symbol_errors = port_stats->rx_symbol_errors;
1189 adapter_stats->rx_pause_frames = port_stats->rx_pause_frames;
1190 adapter_stats->rx_pause_on_frames = port_stats->rx_pause_on_frames;
1191 adapter_stats->rx_pause_off_frames = port_stats->rx_pause_off_frames;
1192 adapter_stats->rx_frames_too_long = port_stats->rx_frames_too_long;
1193 adapter_stats->rx_internal_mac_errors =
1194 port_stats->rx_internal_mac_errors;
1195 adapter_stats->rx_undersize_pkts = port_stats->rx_undersize_pkts;
1196 adapter_stats->rx_oversize_pkts = port_stats->rx_oversize_pkts;
1197 adapter_stats->rx_fragment_pkts = port_stats->rx_fragment_pkts;
1198 adapter_stats->rx_jabbers = port_stats->rx_jabbers;
1199 adapter_stats->rx_control_frames = port_stats->rx_control_frames;
1200 adapter_stats->rx_control_frames_unknown_opcode =
1201 port_stats->rx_control_frames_unknown_opcode;
1202 adapter_stats->rx_in_range_errors = port_stats->rx_in_range_errors;
1203 adapter_stats->rx_out_of_range_errors =
1204 port_stats->rx_out_of_range_errors;
1205 adapter_stats->rx_address_match_errors =
1206 port_stats->rx_address_match_errors;
1207 adapter_stats->rx_vlan_mismatch_errors =
1208 port_stats->rx_vlan_mismatch_errors;
1209 adapter_stats->rx_dropped_too_small = port_stats->rx_dropped_too_small;
1210 adapter_stats->rx_dropped_too_short = port_stats->rx_dropped_too_short;
1211 adapter_stats->rx_dropped_header_too_small =
1212 port_stats->rx_dropped_header_too_small;
1213 adapter_stats->rx_dropped_invalid_tcp_length =
1214 port_stats->rx_dropped_invalid_tcp_length;
1215 adapter_stats->rx_dropped_runt = port_stats->rx_dropped_runt;
1216 adapter_stats->rx_ip_checksum_errors =
1217 port_stats->rx_ip_checksum_errors;
1218 adapter_stats->rx_tcp_checksum_errors =
1219 port_stats->rx_tcp_checksum_errors;
1220 adapter_stats->rx_udp_checksum_errors =
1221 port_stats->rx_udp_checksum_errors;
1222 adapter_stats->rx_non_rss_pkts = port_stats->rx_non_rss_pkts;
1223 adapter_stats->rx_ipv4_pkts = port_stats->rx_ipv4_pkts;
1224 adapter_stats->rx_ipv6_pkts = port_stats->rx_ipv6_pkts;
1225 adapter_stats->rx_ipv4_bytes = port_stats->rx_ipv4_bytes;
1226 adapter_stats->rx_ipv6_bytes = port_stats->rx_ipv6_bytes;
1227 adapter_stats->rx_nic_pkts = port_stats->rx_nic_pkts;
1228 adapter_stats->rx_tcp_pkts = port_stats->rx_tcp_pkts;
1229 adapter_stats->rx_iscsi_pkts = port_stats->rx_iscsi_pkts;
1230 adapter_stats->rx_management_pkts = port_stats->rx_management_pkts;
1231 adapter_stats->rx_switched_unicast_pkts =
1232 port_stats->rx_switched_unicast_pkts;
1233 adapter_stats->rx_switched_multicast_pkts =
1234 port_stats->rx_switched_multicast_pkts;
1235 adapter_stats->rx_switched_broadcast_pkts =
1236 port_stats->rx_switched_broadcast_pkts;
1237 adapter_stats->num_forwards = port_stats->num_forwards;
1238 adapter_stats->rx_fifo_overflow = port_stats->rx_fifo_overflow;
1239 adapter_stats->rx_input_fifo_overflow =
1240 port_stats->rx_input_fifo_overflow;
1241 adapter_stats->rx_drops_too_many_frags =
1242 port_stats->rx_drops_too_many_frags;
1243 adapter_stats->rx_drops_invalid_queue =
1244 port_stats->rx_drops_invalid_queue;
1245 adapter_stats->rx_drops_mtu = port_stats->rx_drops_mtu;
1246 adapter_stats->rx_pkts_64_bytes = port_stats->rx_pkts_64_bytes;
1247 adapter_stats->rx_pkts_65_to_127_bytes =
1248 port_stats->rx_pkts_65_to_127_bytes;
1249 adapter_stats->rx_pkts_128_to_255_bytes =
1250 port_stats->rx_pkts_128_to_255_bytes;
1251 adapter_stats->rx_pkts_256_to_511_bytes =
1252 port_stats->rx_pkts_256_to_511_bytes;
1253 adapter_stats->rx_pkts_512_to_1023_bytes =
1254 port_stats->rx_pkts_512_to_1023_bytes;
1255 adapter_stats->rx_pkts_1024_to_1518_bytes =
1256 port_stats->rx_pkts_1024_to_1518_bytes;
1257 adapter_stats->rx_pkts_1519_to_2047_bytes =
1258 port_stats->rx_pkts_1519_to_2047_bytes;
1259 adapter_stats->rx_pkts_2048_to_4095_bytes =
1260 port_stats->rx_pkts_2048_to_4095_bytes;
1261 adapter_stats->rx_pkts_4096_to_8191_bytes =
1262 port_stats->rx_pkts_4096_to_8191_bytes;
1263 adapter_stats->rx_pkts_8192_to_9216_bytes =
1264 port_stats->rx_pkts_8192_to_9216_bytes;
1265}
1266
1267
1268
1269static void
1270copy_stats_to_sc_be2(POCE_SOFTC sc)
1271{
1272 struct oce_be_stats *adapter_stats;
1273 struct oce_pmem_stats *pmem;
1274 struct oce_rxf_stats_v0 *rxf_stats;
1275 struct oce_port_rxf_stats_v0 *port_stats;
1276 struct mbx_get_nic_stats_v0 *nic_mbx;
1277 uint32_t port = sc->port_id;
1278
1279 nic_mbx = OCE_DMAPTR(&sc->stats_mem, struct mbx_get_nic_stats_v0);
1280 pmem = &nic_mbx->params.rsp.stats.pmem;
1281 rxf_stats = &nic_mbx->params.rsp.stats.rxf;
1282 port_stats = &nic_mbx->params.rsp.stats.rxf.port[port];
1283
1284 adapter_stats = &sc->oce_stats_info.u0.be;
1285
1286
1287 /* Update stats */
1288 adapter_stats->rx_pause_frames = port_stats->rx_pause_frames;
1289 adapter_stats->rx_crc_errors = port_stats->rx_crc_errors;
1290 adapter_stats->rx_control_frames = port_stats->rx_control_frames;
1291 adapter_stats->rx_in_range_errors = port_stats->rx_in_range_errors;
1292 adapter_stats->rx_frame_too_long = port_stats->rx_frame_too_long;
1293 adapter_stats->rx_dropped_runt = port_stats->rx_dropped_runt;
1294 adapter_stats->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
1295 adapter_stats->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
1296 adapter_stats->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
1297 adapter_stats->rxpp_fifo_overflow_drop =
1298 port_stats->rxpp_fifo_overflow_drop;
1299 adapter_stats->rx_dropped_tcp_length =
1300 port_stats->rx_dropped_tcp_length;
1301 adapter_stats->rx_dropped_too_small = port_stats->rx_dropped_too_small;
1302 adapter_stats->rx_dropped_too_short = port_stats->rx_dropped_too_short;
1303 adapter_stats->rx_out_range_errors = port_stats->rx_out_range_errors;
1304 adapter_stats->rx_dropped_header_too_small =
1305 port_stats->rx_dropped_header_too_small;
1306 adapter_stats->rx_input_fifo_overflow_drop =
1307 port_stats->rx_input_fifo_overflow_drop;
1308 adapter_stats->rx_address_match_errors =
1309 port_stats->rx_address_match_errors;
1310 adapter_stats->rx_alignment_symbol_errors =
1311 port_stats->rx_alignment_symbol_errors;
1312 adapter_stats->tx_pauseframes = port_stats->tx_pauseframes;
1313 adapter_stats->tx_controlframes = port_stats->tx_controlframes;
1314
1315 if (sc->if_id)
1316 adapter_stats->jabber_events = rxf_stats->port1_jabber_events;
1317 else
1318 adapter_stats->jabber_events = rxf_stats->port0_jabber_events;
1319
1320 adapter_stats->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
1321 adapter_stats->rx_drops_no_txpb = rxf_stats->rx_drops_no_txpb;
1322 adapter_stats->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
1323 adapter_stats->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring;
1324 adapter_stats->forwarded_packets = rxf_stats->forwarded_packets;
1325 adapter_stats->rx_drops_mtu = rxf_stats->rx_drops_mtu;
1326 adapter_stats->rx_drops_no_tpre_descr =
1327 rxf_stats->rx_drops_no_tpre_descr;
1328 adapter_stats->rx_drops_too_many_frags =
1329 rxf_stats->rx_drops_too_many_frags;
1330 adapter_stats->eth_red_drops = pmem->eth_red_drops;
1331}
1332
1333
1334static void
1335copy_stats_to_sc_be3(POCE_SOFTC sc)
1336{
1337 struct oce_be_stats *adapter_stats;
1338 struct oce_pmem_stats *pmem;
1339 struct oce_rxf_stats_v1 *rxf_stats;
1340 struct oce_port_rxf_stats_v1 *port_stats;
1341 struct mbx_get_nic_stats *nic_mbx;
1342 uint32_t port = sc->port_id;
1343
1344 nic_mbx = OCE_DMAPTR(&sc->stats_mem, struct mbx_get_nic_stats);
1345 pmem = &nic_mbx->params.rsp.stats.pmem;
1346 rxf_stats = &nic_mbx->params.rsp.stats.rxf;
1347 port_stats = &nic_mbx->params.rsp.stats.rxf.port[port];
1348
1349 adapter_stats = &sc->oce_stats_info.u0.be;
1350
1351 /* Update stats */
1352 adapter_stats->pmem_fifo_overflow_drop =
1353 port_stats->pmem_fifo_overflow_drop;
1354 adapter_stats->rx_priority_pause_frames =
1355 port_stats->rx_priority_pause_frames;
1356 adapter_stats->rx_pause_frames = port_stats->rx_pause_frames;
1357 adapter_stats->rx_crc_errors = port_stats->rx_crc_errors;
1358 adapter_stats->rx_control_frames = port_stats->rx_control_frames;
1359 adapter_stats->rx_in_range_errors = port_stats->rx_in_range_errors;
1360 adapter_stats->rx_frame_too_long = port_stats->rx_frame_too_long;
1361 adapter_stats->rx_dropped_runt = port_stats->rx_dropped_runt;
1362 adapter_stats->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
1363 adapter_stats->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
1364 adapter_stats->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
1365 adapter_stats->rx_dropped_tcp_length =
1366 port_stats->rx_dropped_tcp_length;
1367 adapter_stats->rx_dropped_too_small = port_stats->rx_dropped_too_small;
1368 adapter_stats->rx_dropped_too_short = port_stats->rx_dropped_too_short;
1369 adapter_stats->rx_out_range_errors = port_stats->rx_out_range_errors;
1370 adapter_stats->rx_dropped_header_too_small =
1371 port_stats->rx_dropped_header_too_small;
1372 adapter_stats->rx_input_fifo_overflow_drop =
1373 port_stats->rx_input_fifo_overflow_drop;
1374 adapter_stats->rx_address_match_errors =
1375 port_stats->rx_address_match_errors;
1376 adapter_stats->rx_alignment_symbol_errors =
1377 port_stats->rx_alignment_symbol_errors;
1378 adapter_stats->rxpp_fifo_overflow_drop =
1379 port_stats->rxpp_fifo_overflow_drop;
1380 adapter_stats->tx_pauseframes = port_stats->tx_pauseframes;
1381 adapter_stats->tx_controlframes = port_stats->tx_controlframes;
1382 adapter_stats->jabber_events = port_stats->jabber_events;
1383
1384 adapter_stats->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
1385 adapter_stats->rx_drops_no_txpb = rxf_stats->rx_drops_no_txpb;
1386 adapter_stats->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
1387 adapter_stats->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring;
1388 adapter_stats->forwarded_packets = rxf_stats->forwarded_packets;
1389 adapter_stats->rx_drops_mtu = rxf_stats->rx_drops_mtu;
1390 adapter_stats->rx_drops_no_tpre_descr =
1391 rxf_stats->rx_drops_no_tpre_descr;
1392 adapter_stats->rx_drops_too_many_frags =
1393 rxf_stats->rx_drops_too_many_frags;
1394
1395 adapter_stats->eth_red_drops = pmem->eth_red_drops;
1396}
1397
1398
1399int
1400oce_stats_init(POCE_SOFTC sc)
1401{
1402 int rc = 0, sz;
1403
1404 if (IS_BE(sc) || IS_SH(sc)) {
1405 if (sc->flags & OCE_FLAGS_BE2)
1406 sz = sizeof(struct mbx_get_nic_stats_v0);
1407 else
1408 sz = sizeof(struct mbx_get_nic_stats);
1409 } else
1410 sz = sizeof(struct mbx_get_pport_stats);
1411
1412 rc = oce_dma_alloc(sc, sz, &sc->stats_mem, 0);
1413
1414 return rc;
1415}
1416
1417
1418void
1419oce_stats_free(POCE_SOFTC sc)
1420{
1421
1422 oce_dma_free(sc, &sc->stats_mem);
1423
1424}
1425
1426
1427int
1428oce_refresh_nic_stats(POCE_SOFTC sc)
1429{
1430 int rc = 0, reset = 0;
1431
1432 if (IS_BE(sc) || IS_SH(sc)) {
1433 if (sc->flags & OCE_FLAGS_BE2) {
1434 rc = oce_mbox_get_nic_stats_v0(sc, &sc->stats_mem);
1435 if (!rc)
1436 copy_stats_to_sc_be2(sc);
1437 } else {
1438 rc = oce_mbox_get_nic_stats(sc, &sc->stats_mem);
1439 if (!rc)
1440 copy_stats_to_sc_be3(sc);
1441 }
1442
1443 } else {
1444 rc = oce_mbox_get_pport_stats(sc, &sc->stats_mem, reset);
1445 if (!rc)
1446 copy_stats_to_sc_xe201(sc);
1447 }
1448
1449 return rc;
1450}
1451
1452static int
1453oce_sysctl_sfp_vpd_dump(SYSCTL_HANDLER_ARGS)
1454{
1455 int result = 0, error;
1456 int rc = 0;
1457 POCE_SOFTC sc = (POCE_SOFTC) arg1;
1458
1459 /* sysctl default handler */
1460 error = sysctl_handle_int(oidp, &result, 0, req);
1461 if (error || !req->newptr)
1462 return (error);
1463
1464 if(result == -1) {
1465 return EINVAL;
1466 }
1467 bzero((char *)sfp_vpd_dump_buffer, TRANSCEIVER_DATA_SIZE);
1468
1469 rc = oce_mbox_read_transrecv_data(sc, PAGE_NUM_A0);
1470 if(rc)
1471 return rc;
1472
1473 rc = oce_mbox_read_transrecv_data(sc, PAGE_NUM_A2);
1474 if(rc)
1475 return rc;
1476
1477 return rc;
1478}