xref: /freebsd/sys/dev/ixgbe/if_bypass.c (revision f1951fd745b894fe6586c298874af98544a5e272)
1 /******************************************************************************
2 
3   Copyright (c) 2001-2017, Intel Corporation
4   All rights reserved.
5 
6   Redistribution and use in source and binary forms, with or without
7   modification, are permitted provided that the following conditions are met:
8 
9    1. Redistributions of source code must retain the above copyright notice,
10       this list of conditions and the following disclaimer.
11 
12    2. Redistributions in binary form must reproduce the above copyright
13       notice, this list of conditions and the following disclaimer in the
14       documentation and/or other materials provided with the distribution.
15 
16    3. Neither the name of the Intel Corporation nor the names of its
17       contributors may be used to endorse or promote products derived from
18       this software without specific prior written permission.
19 
20   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30   POSSIBILITY OF SUCH DAMAGE.
31 
32 ******************************************************************************/
33 /*$FreeBSD$*/
34 
35 
36 #include "ixgbe.h"
37 
38 /************************************************************************
39  * ixgbe_bypass_mutex_enter
40  *
41  *   Mutex support for the bypass feature. Using a dual lock
42  *   to facilitate a privileged access to the watchdog update
43  *   over other threads.
44  ************************************************************************/
45 static void
46 ixgbe_bypass_mutex_enter(struct adapter *adapter)
47 {
48 	while (atomic_cmpset_int(&adapter->bypass.low, 0, 1) == 0)
49 		usec_delay(3000);
50 	while (atomic_cmpset_int(&adapter->bypass.high, 0, 1) == 0)
51 		usec_delay(3000);
52 	return;
53 } /* ixgbe_bypass_mutex_enter */
54 
55 /************************************************************************
56  * ixgbe_bypass_mutex_clear
57  ************************************************************************/
58 static void
59 ixgbe_bypass_mutex_clear(struct adapter *adapter)
60 {
61 	while (atomic_cmpset_int(&adapter->bypass.high, 1, 0) == 0)
62 		usec_delay(6000);
63 	while (atomic_cmpset_int(&adapter->bypass.low, 1, 0) == 0)
64 		usec_delay(6000);
65 	return;
66 } /* ixgbe_bypass_mutex_clear */
67 
68 /************************************************************************
69  * ixgbe_bypass_wd_mutex_enter
70  *
71  *   Watchdog entry is allowed to simply grab the high priority
72  ************************************************************************/
73 static void
74 ixgbe_bypass_wd_mutex_enter(struct adapter *adapter)
75 {
76 	while (atomic_cmpset_int(&adapter->bypass.high, 0, 1) == 0)
77 		usec_delay(3000);
78 	return;
79 } /* ixgbe_bypass_wd_mutex_enter */
80 
81 /************************************************************************
82  * ixgbe_bypass_wd_mutex_clear
83  ************************************************************************/
84 static void
85 ixgbe_bypass_wd_mutex_clear(struct adapter *adapter)
86 {
87 	while (atomic_cmpset_int(&adapter->bypass.high, 1, 0) == 0)
88 		usec_delay(6000);
89 	return;
90 } /* ixgbe_bypass_wd_mutex_clear */
91 
92 /************************************************************************
93  * ixgbe_get_bypass_time
94  ************************************************************************/
95 static void
96 ixgbe_get_bypass_time(u32 *year, u32 *sec)
97 {
98 	struct timespec current;
99 
100 	*year = 1970;           /* time starts at 01/01/1970 */
101 	nanotime(&current);
102 	*sec = current.tv_sec;
103 
104 	while(*sec > SEC_THIS_YEAR(*year)) {
105 		*sec -= SEC_THIS_YEAR(*year);
106 		(*year)++;
107 	}
108 } /* ixgbe_get_bypass_time */
109 
110 /************************************************************************
111  * ixgbe_bp_version
112  *
113  *   Display the feature version
114  ************************************************************************/
115 static int
116 ixgbe_bp_version(SYSCTL_HANDLER_ARGS)
117 {
118 	struct adapter  *adapter = (struct adapter *) arg1;
119 	struct ixgbe_hw *hw = &adapter->hw;
120 	int             error = 0;
121 	static int      version = 0;
122 	u32             cmd;
123 
124 	ixgbe_bypass_mutex_enter(adapter);
125 	cmd = BYPASS_PAGE_CTL2 | BYPASS_WE;
126 	cmd |= (BYPASS_EEPROM_VER_ADD << BYPASS_CTL2_OFFSET_SHIFT) &
127 	    BYPASS_CTL2_OFFSET_M;
128 	if ((error = hw->mac.ops.bypass_rw(hw, cmd, &version) != 0))
129 		goto err;
130 	msec_delay(100);
131 	cmd &= ~BYPASS_WE;
132 	if ((error = hw->mac.ops.bypass_rw(hw, cmd, &version) != 0))
133 		goto err;
134 	ixgbe_bypass_mutex_clear(adapter);
135 	version &= BYPASS_CTL2_DATA_M;
136 	error = sysctl_handle_int(oidp, &version, 0, req);
137 	return (error);
138 err:
139 	ixgbe_bypass_mutex_clear(adapter);
140 	return (error);
141 
142 } /* ixgbe_bp_version */
143 
144 /************************************************************************
145  * ixgbe_bp_set_state
146  *
147  *   Show/Set the Bypass State:
148  *	1 = NORMAL
149  *	2 = BYPASS
150  *	3 = ISOLATE
151  *
152  *	With no argument the state is displayed,
153  *	passing a value will set it.
154  ************************************************************************/
155 static int
156 ixgbe_bp_set_state(SYSCTL_HANDLER_ARGS)
157 {
158 	struct adapter  *adapter = (struct adapter *) arg1;
159 	struct ixgbe_hw *hw = &adapter->hw;
160 	int             error = 0;
161 	static int      state = 0;
162 
163 	/* Get the current state */
164 	ixgbe_bypass_mutex_enter(adapter);
165 	error = hw->mac.ops.bypass_rw(hw,
166 	    BYPASS_PAGE_CTL0, &state);
167 	ixgbe_bypass_mutex_clear(adapter);
168 	if (error != 0)
169 		return (error);
170 	state = (state >> BYPASS_STATUS_OFF_SHIFT) & 0x3;
171 
172 	error = sysctl_handle_int(oidp, &state, 0, req);
173 	if ((error != 0) || (req->newptr == NULL))
174 		return (error);
175 
176 	/* Sanity check new state */
177 	switch (state) {
178 	case BYPASS_NORM:
179 	case BYPASS_BYPASS:
180 	case BYPASS_ISOLATE:
181 		break;
182 	default:
183 		return (EINVAL);
184 	}
185 	ixgbe_bypass_mutex_enter(adapter);
186 	if ((error = hw->mac.ops.bypass_set(hw, BYPASS_PAGE_CTL0,
187 	    BYPASS_MODE_OFF_M, state) != 0))
188 		goto out;
189 	/* Set AUTO back on so FW can receive events */
190 	error = hw->mac.ops.bypass_set(hw, BYPASS_PAGE_CTL0,
191 	    BYPASS_MODE_OFF_M, BYPASS_AUTO);
192 out:
193 	ixgbe_bypass_mutex_clear(adapter);
194 	usec_delay(6000);
195 	return (error);
196 } /* ixgbe_bp_set_state */
197 
198 /************************************************************************
199  * The following routines control the operational
200  * "rules" of the feature, what behavior will occur
201  * when particular events occur.
202  * 	Values are:
203  *		0 - no change for the event (NOP)
204  *		1 - go to Normal operation
205  *		2 - go to Bypass operation
206  *		3 - go to Isolate operation
207  * Calling the entry with no argument just displays
208  * the current rule setting.
209  ************************************************************************/
210 
211 /************************************************************************
212  * ixgbe_bp_timeout
213  *
214  * This is to set the Rule for the watchdog,
215  * not the actual watchdog timeout value.
216  ************************************************************************/
217 static int
218 ixgbe_bp_timeout(SYSCTL_HANDLER_ARGS)
219 {
220 	struct adapter  *adapter = (struct adapter *) arg1;
221 	struct ixgbe_hw *hw = &adapter->hw;
222 	int             error = 0;
223 	static int      timeout = 0;
224 
225 	/* Get the current value */
226 	ixgbe_bypass_mutex_enter(adapter);
227 	error = hw->mac.ops.bypass_rw(hw, BYPASS_PAGE_CTL0, &timeout);
228 	ixgbe_bypass_mutex_clear(adapter);
229 	if (error)
230 		return (error);
231 	timeout = (timeout >> BYPASS_WDTIMEOUT_SHIFT) & 0x3;
232 
233 	error = sysctl_handle_int(oidp, &timeout, 0, req);
234 	if ((error) || (req->newptr == NULL))
235 		return (error);
236 
237 	/* Sanity check on the setting */
238 	switch (timeout) {
239 	case BYPASS_NOP:
240 	case BYPASS_NORM:
241 	case BYPASS_BYPASS:
242 	case BYPASS_ISOLATE:
243 		break;
244 	default:
245 		return (EINVAL);
246 	}
247 
248 	/* Set the new state */
249 	ixgbe_bypass_mutex_enter(adapter);
250 	error = hw->mac.ops.bypass_set(hw, BYPASS_PAGE_CTL0,
251 	    BYPASS_WDTIMEOUT_M, timeout << BYPASS_WDTIMEOUT_SHIFT);
252 	ixgbe_bypass_mutex_clear(adapter);
253 	usec_delay(6000);
254 	return (error);
255 } /* ixgbe_bp_timeout */
256 
257 /************************************************************************
258  * ixgbe_bp_main_on
259  ************************************************************************/
260 static int
261 ixgbe_bp_main_on(SYSCTL_HANDLER_ARGS)
262 {
263 	struct adapter  *adapter = (struct adapter *) arg1;
264 	struct ixgbe_hw *hw = &adapter->hw;
265 	int             error = 0;
266 	static int      main_on = 0;
267 
268 	ixgbe_bypass_mutex_enter(adapter);
269 	error = hw->mac.ops.bypass_rw(hw, BYPASS_PAGE_CTL0, &main_on);
270 	main_on = (main_on >> BYPASS_MAIN_ON_SHIFT) & 0x3;
271 	ixgbe_bypass_mutex_clear(adapter);
272 	if (error)
273 		return (error);
274 
275 	error = sysctl_handle_int(oidp, &main_on, 0, req);
276 	if ((error) || (req->newptr == NULL))
277 		return (error);
278 
279 	/* Sanity check on the setting */
280 	switch (main_on) {
281 	case BYPASS_NOP:
282 	case BYPASS_NORM:
283 	case BYPASS_BYPASS:
284 	case BYPASS_ISOLATE:
285 		break;
286 	default:
287 		return (EINVAL);
288 	}
289 
290 	/* Set the new state */
291 	ixgbe_bypass_mutex_enter(adapter);
292 	error = hw->mac.ops.bypass_set(hw, BYPASS_PAGE_CTL0,
293 	    BYPASS_MAIN_ON_M, main_on << BYPASS_MAIN_ON_SHIFT);
294 	ixgbe_bypass_mutex_clear(adapter);
295 	usec_delay(6000);
296 	return (error);
297 } /* ixgbe_bp_main_on */
298 
299 /************************************************************************
300  * ixgbe_bp_main_off
301  ************************************************************************/
302 static int
303 ixgbe_bp_main_off(SYSCTL_HANDLER_ARGS)
304 {
305 	struct adapter  *adapter = (struct adapter *) arg1;
306 	struct ixgbe_hw *hw = &adapter->hw;
307 	int             error = 0;
308 	static int      main_off = 0;
309 
310 	ixgbe_bypass_mutex_enter(adapter);
311 	error = hw->mac.ops.bypass_rw(hw, BYPASS_PAGE_CTL0, &main_off);
312 	ixgbe_bypass_mutex_clear(adapter);
313 	if (error)
314 		return (error);
315 	main_off = (main_off >> BYPASS_MAIN_OFF_SHIFT) & 0x3;
316 
317 	error = sysctl_handle_int(oidp, &main_off, 0, req);
318 	if ((error) || (req->newptr == NULL))
319 		return (error);
320 
321 	/* Sanity check on the setting */
322 	switch (main_off) {
323 	case BYPASS_NOP:
324 	case BYPASS_NORM:
325 	case BYPASS_BYPASS:
326 	case BYPASS_ISOLATE:
327 		break;
328 	default:
329 		return (EINVAL);
330 	}
331 
332 	/* Set the new state */
333 	ixgbe_bypass_mutex_enter(adapter);
334 	error = hw->mac.ops.bypass_set(hw, BYPASS_PAGE_CTL0,
335 	    BYPASS_MAIN_OFF_M, main_off << BYPASS_MAIN_OFF_SHIFT);
336 	ixgbe_bypass_mutex_clear(adapter);
337 	usec_delay(6000);
338 	return (error);
339 } /* ixgbe_bp_main_off */
340 
341 /************************************************************************
342  * ixgbe_bp_aux_on
343  ************************************************************************/
344 static int
345 ixgbe_bp_aux_on(SYSCTL_HANDLER_ARGS)
346 {
347 	struct adapter  *adapter = (struct adapter *) arg1;
348 	struct ixgbe_hw *hw = &adapter->hw;
349 	int             error = 0;
350 	static int      aux_on = 0;
351 
352 	ixgbe_bypass_mutex_enter(adapter);
353 	error = hw->mac.ops.bypass_rw(hw, BYPASS_PAGE_CTL0, &aux_on);
354 	ixgbe_bypass_mutex_clear(adapter);
355 	if (error)
356 		return (error);
357 	aux_on = (aux_on >> BYPASS_AUX_ON_SHIFT) & 0x3;
358 
359 	error = sysctl_handle_int(oidp, &aux_on, 0, req);
360 	if ((error) || (req->newptr == NULL))
361 		return (error);
362 
363 	/* Sanity check on the setting */
364 	switch (aux_on) {
365 	case BYPASS_NOP:
366 	case BYPASS_NORM:
367 	case BYPASS_BYPASS:
368 	case BYPASS_ISOLATE:
369 		break;
370 	default:
371 		return (EINVAL);
372 	}
373 
374 	/* Set the new state */
375 	ixgbe_bypass_mutex_enter(adapter);
376 	error = hw->mac.ops.bypass_set(hw, BYPASS_PAGE_CTL0,
377 	    BYPASS_AUX_ON_M, aux_on << BYPASS_AUX_ON_SHIFT);
378 	ixgbe_bypass_mutex_clear(adapter);
379 	usec_delay(6000);
380 	return (error);
381 } /* ixgbe_bp_aux_on */
382 
383 /************************************************************************
384  * ixgbe_bp_aux_off
385  ************************************************************************/
386 static int
387 ixgbe_bp_aux_off(SYSCTL_HANDLER_ARGS)
388 {
389 	struct adapter  *adapter = (struct adapter *) arg1;
390 	struct ixgbe_hw *hw = &adapter->hw;
391 	int             error = 0;
392 	static int      aux_off = 0;
393 
394 	ixgbe_bypass_mutex_enter(adapter);
395 	error = hw->mac.ops.bypass_rw(hw, BYPASS_PAGE_CTL0, &aux_off);
396 	ixgbe_bypass_mutex_clear(adapter);
397 	if (error)
398 		return (error);
399 	aux_off = (aux_off >> BYPASS_AUX_OFF_SHIFT) & 0x3;
400 
401 	error = sysctl_handle_int(oidp, &aux_off, 0, req);
402 	if ((error) || (req->newptr == NULL))
403 		return (error);
404 
405 	/* Sanity check on the setting */
406 	switch (aux_off) {
407 	case BYPASS_NOP:
408 	case BYPASS_NORM:
409 	case BYPASS_BYPASS:
410 	case BYPASS_ISOLATE:
411 		break;
412 	default:
413 		return (EINVAL);
414 	}
415 
416 	/* Set the new state */
417 	ixgbe_bypass_mutex_enter(adapter);
418 	error = hw->mac.ops.bypass_set(hw, BYPASS_PAGE_CTL0,
419 	    BYPASS_AUX_OFF_M, aux_off << BYPASS_AUX_OFF_SHIFT);
420 	ixgbe_bypass_mutex_clear(adapter);
421 	usec_delay(6000);
422 	return (error);
423 } /* ixgbe_bp_aux_off */
424 
425 /************************************************************************
426  * ixgbe_bp_wd_set - Set the Watchdog timer value
427  *
428  *   Valid settings are:
429  *	- 0 will disable the watchdog
430  *	- 1, 2, 3, 4, 8, 16, 32
431  *	- anything else is invalid and will be ignored
432  ************************************************************************/
433 static int
434 ixgbe_bp_wd_set(SYSCTL_HANDLER_ARGS)
435 {
436 	struct adapter  *adapter = (struct adapter *) arg1;
437 	struct ixgbe_hw *hw = &adapter->hw;
438 	int             error, tmp;
439 	static int      timeout = 0;
440 	u32             mask, arg;
441 
442 	/* Get the current hardware value */
443 	ixgbe_bypass_mutex_enter(adapter);
444 	error = hw->mac.ops.bypass_rw(hw, BYPASS_PAGE_CTL0, &tmp);
445 	ixgbe_bypass_mutex_clear(adapter);
446 	if (error)
447 		return (error);
448 	/*
449 	 * If armed keep the displayed value,
450 	 * else change the display to zero.
451 	 */
452 	if ((tmp & (0x1 << BYPASS_WDT_ENABLE_SHIFT)) == 0)
453 		timeout = 0;
454 
455 	error = sysctl_handle_int(oidp, &timeout, 0, req);
456 	if ((error) || (req->newptr == NULL))
457 		return (error);
458 
459 	arg = 0x1 << BYPASS_WDT_ENABLE_SHIFT;
460 	mask = BYPASS_WDT_ENABLE_M | BYPASS_WDT_VALUE_M;
461 	switch (timeout) {
462 	case 0: /* disables the timer */
463 		arg = BYPASS_PAGE_CTL0;
464 		mask = BYPASS_WDT_ENABLE_M;
465 		break;
466 	case 1:
467 		arg |= BYPASS_WDT_1_5 << BYPASS_WDT_TIME_SHIFT;
468 		break;
469 	case 2:
470 		arg |= BYPASS_WDT_2 << BYPASS_WDT_TIME_SHIFT;
471 		break;
472 	case 3:
473 		arg |= BYPASS_WDT_3 << BYPASS_WDT_TIME_SHIFT;
474 		break;
475 	case 4:
476 		arg |= BYPASS_WDT_4 << BYPASS_WDT_TIME_SHIFT;
477 		break;
478 	case 8:
479 		arg |= BYPASS_WDT_8 << BYPASS_WDT_TIME_SHIFT;
480 		break;
481 	case 16:
482 		arg |= BYPASS_WDT_16 << BYPASS_WDT_TIME_SHIFT;
483 		break;
484 	case 32:
485 		arg |= BYPASS_WDT_32 << BYPASS_WDT_TIME_SHIFT;
486 		break;
487 	default:
488 		return (EINVAL);
489 	}
490 
491 	/* Set the new watchdog */
492 	ixgbe_bypass_mutex_enter(adapter);
493 	error = hw->mac.ops.bypass_set(hw, BYPASS_PAGE_CTL0, mask, arg);
494 	ixgbe_bypass_mutex_clear(adapter);
495 
496 	return (error);
497 } /* ixgbe_bp_wd_set */
498 
499 /************************************************************************
500  * ixgbe_bp_wd_reset - Reset the Watchdog timer
501  *
502  *    To activate this it must be called with any argument.
503  ************************************************************************/
504 static int
505 ixgbe_bp_wd_reset(SYSCTL_HANDLER_ARGS)
506 {
507 	struct adapter  *adapter = (struct adapter *) arg1;
508 	struct ixgbe_hw *hw = &adapter->hw;
509 	u32             sec, year;
510 	int             cmd, count = 0, error = 0;
511 	int             reset_wd = 0;
512 
513 	error = sysctl_handle_int(oidp, &reset_wd, 0, req);
514 	if ((error) || (req->newptr == NULL))
515 		return (error);
516 
517 	cmd = BYPASS_PAGE_CTL1 | BYPASS_WE | BYPASS_CTL1_WDT_PET;
518 
519 	/* Resync the FW time while writing to CTL1 anyway */
520 	ixgbe_get_bypass_time(&year, &sec);
521 
522 	cmd |= (sec & BYPASS_CTL1_TIME_M) | BYPASS_CTL1_VALID;
523 	cmd |= BYPASS_CTL1_OFFTRST;
524 
525 	ixgbe_bypass_wd_mutex_enter(adapter);
526 	error = hw->mac.ops.bypass_rw(hw, cmd, &reset_wd);
527 
528 	/* Read until it matches what we wrote, or we time out */
529 	do {
530 		if (count++ > 10) {
531 			error = IXGBE_BYPASS_FW_WRITE_FAILURE;
532 			break;
533 		}
534 		error = hw->mac.ops.bypass_rw(hw, BYPASS_PAGE_CTL1, &reset_wd);
535 		if (error != 0) {
536 			error = IXGBE_ERR_INVALID_ARGUMENT;
537 			break;
538 		}
539 	} while (!hw->mac.ops.bypass_valid_rd(cmd, reset_wd));
540 
541 	reset_wd = 0;
542 	ixgbe_bypass_wd_mutex_clear(adapter);
543 	return (error);
544 } /* ixgbe_bp_wd_reset */
545 
546 /************************************************************************
547  * ixgbe_bp_log - Display the bypass log
548  *
549  *   You must pass a non-zero arg to sysctl
550  ************************************************************************/
551 static int
552 ixgbe_bp_log(SYSCTL_HANDLER_ARGS)
553 {
554 	struct adapter             *adapter = (struct adapter *) arg1;
555 	struct ixgbe_hw            *hw = &adapter->hw;
556 	u32                        cmd, base, head;
557 	u32                        log_off, count = 0;
558 	static int                 status = 0;
559 	u8                         data;
560 	struct ixgbe_bypass_eeprom eeprom[BYPASS_MAX_LOGS];
561 	int                        i, error = 0;
562 
563 	error = sysctl_handle_int(oidp, &status, 0, req);
564 	if ((error) || (req->newptr == NULL))
565 		return (error);
566 
567 	/* Keep the log display single-threaded */
568 	while (atomic_cmpset_int(&adapter->bypass.log, 0, 1) == 0)
569 		usec_delay(3000);
570 
571 	ixgbe_bypass_mutex_enter(adapter);
572 
573 	/* Find Current head of the log eeprom offset */
574 	cmd = BYPASS_PAGE_CTL2 | BYPASS_WE;
575 	cmd |= (0x1 << BYPASS_CTL2_OFFSET_SHIFT) & BYPASS_CTL2_OFFSET_M;
576 	error = hw->mac.ops.bypass_rw(hw, cmd, &status);
577 	if (error)
578 		goto unlock_err;
579 
580 	/* wait for the write to stick */
581 	msec_delay(100);
582 
583 	/* Now read the results */
584 	cmd &= ~BYPASS_WE;
585 	error = hw->mac.ops.bypass_rw(hw, cmd, &status);
586 	if (error)
587 		goto unlock_err;
588 
589 	ixgbe_bypass_mutex_clear(adapter);
590 
591 	base = status & BYPASS_CTL2_DATA_M;
592 	head = (status & BYPASS_CTL2_HEAD_M) >> BYPASS_CTL2_HEAD_SHIFT;
593 
594 	/* address of the first log */
595 	log_off = base + (head * 5);
596 
597 	/* extract all the log entries */
598 	while (count < BYPASS_MAX_LOGS) {
599 		eeprom[count].logs = 0;
600 		eeprom[count].actions = 0;
601 
602 		/* Log 5 bytes store in on u32 and a u8 */
603 		for (i = 0; i < 4; i++) {
604 			ixgbe_bypass_mutex_enter(adapter);
605 			error = hw->mac.ops.bypass_rd_eep(hw, log_off + i,
606 			    &data);
607 			ixgbe_bypass_mutex_clear(adapter);
608 			if (error)
609 				return (EINVAL);
610 			eeprom[count].logs += data << (8 * i);
611 		}
612 
613 		ixgbe_bypass_mutex_enter(adapter);
614 		error = hw->mac.ops.bypass_rd_eep(hw,
615 		    log_off + i, &eeprom[count].actions);
616 		ixgbe_bypass_mutex_clear(adapter);
617 		if (error)
618 			return (EINVAL);
619 
620 		/* Quit if not a unread log */
621 		if (!(eeprom[count].logs & BYPASS_LOG_CLEAR_M))
622 			break;
623 		/*
624 		 * Log looks good so store the address where it's
625 		 * Unread Log bit is so we can clear it after safely
626 		 * pulling out all of the log data.
627 		 */
628 		eeprom[count].clear_off = log_off;
629 
630 		count++;
631 		head = head ? head - 1 : BYPASS_MAX_LOGS;
632 		log_off = base + (head * 5);
633 	}
634 
635 	/* reverse order (oldest first) for output */
636 	while (count--) {
637 		int year;
638 		u32 mon, days, hours, min, sec;
639 		u32 time = eeprom[count].logs & BYPASS_LOG_TIME_M;
640 		u32 event = (eeprom[count].logs & BYPASS_LOG_EVENT_M) >>
641 		    BYPASS_LOG_EVENT_SHIFT;
642 		u8 action =  eeprom[count].actions & BYPASS_LOG_ACTION_M;
643 		u16 day_mon[2][13] = {
644 		  {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
645 		  {0, 31, 59, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}
646 		};
647 		char *event_str[] = {"unknown", "main on", "aux on",
648 		    "main off", "aux off", "WDT", "user" };
649 		char *action_str[] = {"ignore", "normal", "bypass", "isolate",};
650 
651 		/* verify vaild data  1 - 6 */
652 		if (event < BYPASS_EVENT_MAIN_ON || event > BYPASS_EVENT_USR)
653 			event = 0;
654 
655 		/*
656 		 * time is in sec's this year, so convert to something
657 		 * printable.
658 		 */
659 		ixgbe_get_bypass_time(&year, &sec);
660 		days = time / SEC_PER_DAY;
661 		for (i = 11; days < day_mon[LEAP_YR(year)][i]; i--)
662 			continue;
663 		mon = i + 1;    /* display month as 1-12 */
664 		time -= (day_mon[LEAP_YR(year)][i] * SEC_PER_DAY);
665 		days = (time / SEC_PER_DAY) + 1;  /* first day is 1 */
666 		time %= SEC_PER_DAY;
667 		hours = time / (60 * 60);
668 		time %= (60 * 60);
669 		min = time / 60;
670 		sec = time % 60;
671 		device_printf(adapter->dev,
672 		    "UT %02d/%02d %02d:%02d:%02d %8.8s -> %7.7s\n",
673 		    mon, days, hours, min, sec, event_str[event],
674 		    action_str[action]);
675 		cmd = BYPASS_PAGE_CTL2 | BYPASS_WE | BYPASS_CTL2_RW;
676 		cmd |= ((eeprom[count].clear_off + 3)
677 		    << BYPASS_CTL2_OFFSET_SHIFT) & BYPASS_CTL2_OFFSET_M;
678 		cmd |= ((eeprom[count].logs & ~BYPASS_LOG_CLEAR_M) >> 24);
679 
680 		ixgbe_bypass_mutex_enter(adapter);
681 
682 		error = hw->mac.ops.bypass_rw(hw, cmd, &status);
683 
684 		/* wait for the write to stick */
685 		msec_delay(100);
686 
687 		ixgbe_bypass_mutex_clear(adapter);
688 
689 		if (error)
690 			return (EINVAL);
691 	}
692 
693 	status = 0; /* reset */
694 	/* Another log command can now run */
695 	while (atomic_cmpset_int(&adapter->bypass.log, 1, 0) == 0)
696 		usec_delay(3000);
697 	return (error);
698 
699 unlock_err:
700 	ixgbe_bypass_mutex_clear(adapter);
701 	status = 0; /* reset */
702 	while (atomic_cmpset_int(&adapter->bypass.log, 1, 0) == 0)
703 		usec_delay(3000);
704 	return (EINVAL);
705 } /* ixgbe_bp_log */
706 
707 /************************************************************************
708  * ixgbe_bypass_init - Set up infrastructure for the bypass feature
709  *
710  *   Do time and sysctl initialization here.  This feature is
711  *   only enabled for the first port of a bypass adapter.
712  ************************************************************************/
713 void
714 ixgbe_bypass_init(struct adapter *adapter)
715 {
716 	struct ixgbe_hw        *hw = &adapter->hw;
717 	device_t               dev = adapter->dev;
718 	struct sysctl_oid      *bp_node;
719 	struct sysctl_oid_list *bp_list;
720 	u32                    mask, value, sec, year;
721 
722 	if (!(adapter->feat_cap & IXGBE_FEATURE_BYPASS))
723 		return;
724 
725 	/* First set up time for the hardware */
726 	ixgbe_get_bypass_time(&year, &sec);
727 
728 	mask = BYPASS_CTL1_TIME_M
729 	     | BYPASS_CTL1_VALID_M
730 	     | BYPASS_CTL1_OFFTRST_M;
731 
732 	value = (sec & BYPASS_CTL1_TIME_M)
733 	      | BYPASS_CTL1_VALID
734 	      | BYPASS_CTL1_OFFTRST;
735 
736 	ixgbe_bypass_mutex_enter(adapter);
737 	hw->mac.ops.bypass_set(hw, BYPASS_PAGE_CTL1, mask, value);
738 	ixgbe_bypass_mutex_clear(adapter);
739 
740 	/* Now set up the SYSCTL infrastructure */
741 
742 	/*
743 	 * The log routine is kept separate from the other
744 	 * children so a general display command like:
745 	 * `sysctl dev.ix.0.bypass` will not show the log.
746 	 */
747 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
748 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
749 	    OID_AUTO, "bypass_log", CTLTYPE_INT | CTLFLAG_RW,
750 	    adapter, 0, ixgbe_bp_log, "I", "Bypass Log");
751 
752 	/* All other setting are hung from the 'bypass' node */
753 	bp_node = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev),
754 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
755 	    OID_AUTO, "bypass", CTLFLAG_RD, NULL, "Bypass");
756 
757 	bp_list = SYSCTL_CHILDREN(bp_node);
758 
759 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
760 	    OID_AUTO, "version", CTLTYPE_INT | CTLFLAG_RD,
761 	    adapter, 0, ixgbe_bp_version, "I", "Bypass Version");
762 
763 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
764 	    OID_AUTO, "state", CTLTYPE_INT | CTLFLAG_RW,
765 	    adapter, 0, ixgbe_bp_set_state, "I", "Bypass State");
766 
767 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
768 	    OID_AUTO, "timeout", CTLTYPE_INT | CTLFLAG_RW,
769 	    adapter, 0, ixgbe_bp_timeout, "I", "Bypass Timeout");
770 
771 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
772 	    OID_AUTO, "main_on", CTLTYPE_INT | CTLFLAG_RW,
773 	    adapter, 0, ixgbe_bp_main_on, "I", "Bypass Main On");
774 
775 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
776 	    OID_AUTO, "main_off", CTLTYPE_INT | CTLFLAG_RW,
777 	    adapter, 0, ixgbe_bp_main_off, "I", "Bypass Main Off");
778 
779 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
780 	    OID_AUTO, "aux_on", CTLTYPE_INT | CTLFLAG_RW,
781 	    adapter, 0, ixgbe_bp_aux_on, "I", "Bypass Aux On");
782 
783 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
784 	    OID_AUTO, "aux_off", CTLTYPE_INT | CTLFLAG_RW,
785 	    adapter, 0, ixgbe_bp_aux_off, "I", "Bypass Aux Off");
786 
787 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
788 	    OID_AUTO, "wd_set", CTLTYPE_INT | CTLFLAG_RW,
789 	    adapter, 0, ixgbe_bp_wd_set, "I", "Set BP Watchdog");
790 
791 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
792 	    OID_AUTO, "wd_reset", CTLTYPE_INT | CTLFLAG_WR,
793 	    adapter, 0, ixgbe_bp_wd_reset, "S", "Bypass WD Reset");
794 
795 	adapter->feat_en |= IXGBE_FEATURE_BYPASS;
796 } /* ixgbe_bypass_init */
797 
798