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