| blob | 6f39a39c814803e0da29672b3bc34e124f37217f |
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
27 /*
28 * bscv.c - multi-threaded lom driver for the Stiletto platform.
29 */
31 /*
32 * Included files.
33 */
35 #include <sys/note.h>
36 #include <sys/types.h>
37 #include <sys/param.h>
38 #include <sys/uio.h>
39 #include <sys/open.h>
40 #include <sys/cred.h>
41 #include <sys/stream.h>
42 #include <sys/systm.h>
43 #include <sys/conf.h>
44 #include <sys/reboot.h>
45 #include <sys/modctl.h>
46 #include <sys/mkdev.h>
47 #include <sys/errno.h>
48 #include <sys/debug.h>
49 #include <sys/kmem.h>
50 #include <sys/consdev.h>
51 #include <sys/file.h>
52 #include <sys/stat.h>
53 #include <sys/disp.h>
54 #include <sys/ddi.h>
55 #include <sys/sunddi.h>
56 #include <sys/stream.h>
57 #include <sys/strlog.h>
58 #include <sys/log.h>
59 #include <sys/utsname.h>
60 #include <sys/callb.h>
61 #include <sys/sysevent.h>
62 #include <sys/nvpair.h>
63 #include <sys/sysevent/eventdefs.h>
64 #include <sys/sysevent/domain.h>
65 #include <sys/sysevent/env.h>
66 #include <sys/sysevent/dr.h>
68 #include <sys/lom_io.h>
69 #include <sys/bscbus.h>
70 #include <sys/bscv_impl.h>
72 /*
73 * Variables defined here and visible internally only
74 */
78 /*
79 * Forward declarations
80 */
97 #ifdef DEBUG
200 #if defined(__i386) || defined(__amd64)
213 #define WDOG_ON 1
214 #define WDOG_OFF 0
225 /*
226 * Local Definitions
227 */
230 #define BSCV_INST_TO_MINOR(i) (i)
231 #define BSCV_MINOR_TO_INST(m) (m)
233 /*
234 * Strings for daemon event reporting
235 */
253 };
256 {
300 };
302 /*
303 * These store to mapping between the logical service, e.g. chan_prog for
304 * programming, and the actual Xbus channel which carries that traffic.
305 * Any services can be shared on the same channel apart from chan_wdogpat.
306 */
313 /*
314 * cb_ops structure defining the driver entry points
315 */
333 };
335 /*
336 * dev_ops structure defining autoconfiguration driver autoconfiguration
337 * routines
338 */
353 };
355 /*
356 * module configuration section
357 */
359 #ifdef DEBUG
367 BSCV_VERSION_STRING,
369 };
372 MODREV_1,
374 NULL
375 };
377 #ifdef DEBUG
378 /* Tracing is enabled if value is non-zero. */
381 #define BSCV_TRACE if (bscv_trace_flag != 0) bscv_trace
382 #else
383 #define BSCV_TRACE
384 #endif
386 /*
387 * kernel accessible routines. These routines are necessarily global so the
388 * driver can be loaded, and unloaded successfully
389 */
391 /*
392 * function - _init
393 * description - initializes the driver state structure and installs the
394 * driver module into the kernel
395 * inputs - none
396 * outputs - success or failure of module installation
397 */
399 int
401 {
407 }
411 }
414 }
416 /*
417 * function - _info
418 * description - provide information about a kernel loaded module
419 * inputs - module infomation
420 * outputs - success or failure of information request
421 */
423 int
425 {
427 }
429 /*
430 * function - _fini
431 * description - removes a module from the kernel and frees the driver soft
432 * state memory
433 * inputs - none
434 * outputs - success or failure of module removal
435 */
437 int
439 {
444 }
449 }
451 /*
452 * function - bscv_getinfo
453 * description - routine used to provide information on the driver
454 * inputs - device information structure, command, command arg, storage
455 * area for the result
456 * outputs - DDI_SUCCESS or DDI_FAILURE
457 */
459 /*ARGSUSED*/
460 static int
462 {
487 }
490 }
493 /*
494 * function - bscv_attach
495 * description - this routine is responsible for setting aside memory for the
496 * driver data structures, initialising the mutexes and creating
497 * the device minor nodes. Additionally, this routine calls the
498 * the callback routine.
499 * inputs - device information structure, DDI_ATTACH command
500 * outputs - DDI_SUCCESS or DDI_FAILURE
501 */
503 int
505 {
515 DDI_SUCCESS) {
517 }
540 #if defined(__i386) || defined(__amd64)
544 /*
545 * initialise the mutexes
546 */
559 /* Map in physical communication channels */
564 }
567 /* Associate logical channels to physical channels */
579 }
584 /*
585 * now create the minor nodes
586 */
592 }
600 #if defined(__i386) || defined(__amd64)
610 }
612 /*
613 * Before we enable the watchdog - register the panic
614 * callback so that we get called to stop the watchdog
615 * in the case of a panic.
616 */
622 CLK_WATCHDOG_DEFAULT);
626 }
632 }
633 }
635 /*
636 * function - bscv_detach
637 * description - routine that prepares a module to be unloaded. It undoes all
638 * the work done by the bscv_attach)() routine. This is
639 * facilitated by the use of the progress indicator
640 * inputs - device information structure, DDI_DETACH command
641 * outputs - DDI_SUCCESS or DDI_FAILURE
642 */
644 /*ARGSUSED*/
645 static int
647 {
649 }
651 /*
652 * quiesce(9E) entry point.
653 *
654 * This function is called when the system is single-threaded at high
655 * PIL with preemption disabled. Therefore, this function must not be
656 * blocked.
657 *
658 * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
659 * DDI_FAILURE indicates an error condition and should almost never happen.
660 */
661 static int
663 {
672 }
673 #ifdef DEBUG
674 /* Disable tracing, as we are executing at High-Interrupt level */
676 #endif
677 /* quiesce the device */
681 }
683 /*
684 * cb_ops routines
685 */
687 /*
688 * function - bscv_open
689 * description - routine to provide association between user fd and device
690 * minor number. This routine is necessarily simple since a
691 * read/write interface is not provided. Additionally, the
692 * driver does not enforce exclusive access (FEXCL) or
693 * non-blocking during an open (FNDELAY). Deferred attach is
694 * supported.
695 * inputs - device number, flag specifying open type, device type,
696 * permissions
697 * outputs - success or failure of operation
698 */
700 /*ARGSUSED*/
701 static int
703 {
711 }
716 }
719 }
721 /*
722 * function - bscv_close
723 * description - routine to perform the final close on the device. As per the
724 * open routine, neither FEXCL or FNDELAY accesses are enforced
725 * by the driver.
726 * inputs - device number,flag specifying open type, device type,
727 * permissions
728 * outputs - success or failure of operation
729 */
731 /*ARGSUSED1*/
732 static int
734 {
742 }
746 }
748 static int
750 {
760 /*
761 * Work out how many channels are available by looking at the number
762 * of elements of the regs property array.
763 */
767 /* We don't need props anymore. Free memory if it was allocated */
771 /* Check for sanity of nelements */
787 nelements);
789 }
805 /* Rewind all current mappings - avoiding failed one */
806 i--;
809 }
812 }
813 }
817 cleanup_exit:
818 /*
819 * It is important to set nchannels to 0 even if, say, only one of
820 * the two required handles was mapped. If we cannot achieve our
821 * minimum config its not safe to do any IO; this keeps our failure
822 * mode handling simpler.
823 */
826 }
828 static void
830 {
837 }
838 }
840 /*
841 * Map logical services onto physical XBus channels.
842 */
843 static void
845 {
848 /*
849 * We can assert that there will always be at least two channels,
850 * to allow watchdog pats to be segregated from all other traffic.
851 */
855 /*
856 * By default move all other services onto the generic channel unless
857 * the hardware supports additional channels.
858 */
868 }
871 /*
872 * function - bscv_full_stop
873 * description - gracefully shut the lom down during panic or reboot.
874 * Disables the watchdog and sets up serial event reporting.
875 * inputs - soft state pointer
876 * outputs - none
877 */
878 void
880 {
888 /*
889 * Obtain the softstate lock only if it is not already owned,
890 * as this function can be called from a High-level interrupt
891 * context. As a result, our thread cannot sleep.
892 * At end of function, our thread releases the lock only if
893 * it acquired the lock.
894 */
897 #if defined(__i386) || defined(__amd64)
902 }
905 /* set serial event reporting */
909 /* Make sure serial event reporting is on */
913 /* Make sure serial event reporting is on */
918 }
922 /* Do not free the lock if our thread did not obtain it. */
925 }
926 }
928 /*
929 * LOM I/O routines.
930 *
931 * locking
932 *
933 * Two sets of routines are provided:
934 * normal - must be called after acquiring an appropriate lock.
935 * locked - perform all the locking required and return any error
936 * code in the supplied 'res' argument. If there is no
937 * error 'res' is not changed.
938 * The locked routines are designed for use in ioctl commands where
939 * only a single operation needs to be performed and the overhead of
940 * locking and result checking adds significantly to code complexity.
941 *
942 * locking primitives
943 *
944 * bscv_enter() - acquires an I/O lock for the calling thread.
945 * bscv_tryenter() - conditionally acquires an I/O lock for calling thread.
946 * bscv_exit() - releases an I/O lock acquired by bscv_enter().
947 * bscv_held() - used to assert ownership of an I/O lock.
948 *
949 * normal I/O routines
950 *
951 * Note bscv_{put|get}{16|32} routines are big-endian. This assumes that
952 * the firmware works that way too.
953 *
954 * bscv_put8(), bscv_put16, bscv_put32 - write values to the LOM
955 * and handle any retries if necessary.
956 * 16 and 32 bit values are big-endian.
957 * bscv_get8(), bscv_get16, bscv_get32 - read values from the LOM
958 * and handle any retries if necessary.
959 * 16 and 32 bit values are big-endian.
960 * bscv_setclear8() - set or clear the specified bits in the register
961 * at the supplied address.
962 * bscv_setclear8_volatile() - set or clear the specified bits in the
963 * register at the supplied address. If the lom reports
964 * that the registers has changed since the last read
965 * re-read and apply the set or clear to the new bits.
966 * bscv_get8_cached() - Return a cached register value (addr < 0x80).
967 * Does not access the hardware. A read of the hardware
968 * automatically updates this cache.
969 *
970 * locked I/O routines
971 *
972 * bscv_get8_locked(), bscv_rep_get8_locked().
973 *
974 * Call the indicated function from above, but wrapping it with
975 * bscv_enter()/bscv_exit().
976 *
977 *
978 * Fault management
979 *
980 * LOM communications fault are grouped into three categories:
981 * 1) Faulty - the LOM is not responding and no attempt to communicate
982 * with it should be made.
983 * 2) Transient fault - something which might recover after a retry
984 * but which doesn't affect our ability to perform other
985 * commands.
986 * 3) Command error - an inappropriate command was executed. A retry
987 * will not fix it but the command failed.
988 *
989 * The current implementation of the bscv driver is not very good at
990 * noticing command errors due to the structure of the original code
991 * that it is based on. It is possible to extend the driver to do this
992 * and would probably involve having a concept of a "session error"
993 * which is less severe than a fault but means that a sequence of
994 * commands had some fault which cannot be recovered.
995 *
996 *
997 * faults
998 *
999 * bscv_faulty() - returns B_TRUE if the LOM (communications) have been
1000 * declared faulty.
1001 * bscv_clear_fault() - marks the LOM as not faulty.
1002 * bscv_set_fault() - marks the LOM as being faulty.
1003 *
1004 * bscv_clear_fault and bscv_set_fault should generally not be called
1005 * directly.
1006 *
1007 * command errors/transient faults
1008 *
1009 * bscv_retcode() - returns the actual error code of the last operation.
1010 * bscv_should_retry() - determines if last operation may suceed if
1011 * retried.
1012 * bscv_locked_result() - Set the result of a locked register access.
1013 *
1014 * low level I/O primitives
1015 *
1016 * These are generally not called directly. These perform a single
1017 * access to the LOM device. They do not handle retries.
1018 *
1019 * bscv_put8_once()
1020 * bscv_get8_once()
1021 * bscv_probe() - perform a probe (NOP) operation to check out lom comms.
1022 * bscv_resync_comms() - resynchronise communications after a transient fault.
1023 */
1025 static void
1027 {
1031 }
1033 static int
1035 {
1041 }
1043 }
1045 static void
1047 {
1050 }
1052 #ifdef DEBUG
1053 static int
1055 {
1057 }
1060 static void
1062 {
1063 boolean_t needretry;
1070 }
1077 num_failures++) {
1082 }
1083 }
1086 }
1089 /* Failure - we ran out of retries */
1098 }
1099 }
1101 static void
1103 {
1109 }
1111 static void
1113 {
1121 }
1123 static uint8_t
1125 {
1127 boolean_t needretry;
1134 }
1138 num_failures++) {
1143 }
1144 }
1147 }
1150 /* Failure */
1159 }
1164 }
1166 static uint16_t
1168 {
1179 }
1181 static uint32_t
1183 {
1196 }
1198 static void
1201 {
1216 }
1218 static void
1221 {
1223 boolean_t needretry;
1231 }
1240 num_failures++) {
1245 /* Re-read the stale register from the lom */
1252 }
1253 }
1254 }
1257 }
1260 /* Failure */
1266 }
1271 }
1272 }
1274 static void
1277 boolean_t is_write)
1278 {
1290 }
1297 dev_addr);
1298 }
1299 /* We need this because _once routines don't do it */
1302 }
1303 }
1305 /*
1306 * No retry here. If we were AUTOINCR then get/put
1307 * will have retried. For NO_AUTOINCR we cannot retry
1308 * because the data would be corrupted.
1309 */
1311 }
1312 }
1313 }
1315 static uint8_t
1317 {
1319 /* Can be called with or without the lock held */
1322 }
1324 static uint8_t
1326 {
1337 }
1339 static void
1342 {
1348 }
1350 static boolean_t
1352 {
1355 }
1357 static void
1359 {
1364 }
1366 static void
1368 {
1372 }
1374 static boolean_t
1376 {
1379 }
1381 static int
1383 {
1387 }
1389 static int
1391 {
1394 /* This command is due to an I/O fault - retry might fix */
1397 /*
1398 * The command itself was bad - there is no point in fixing
1399 * Note. Whatever happens we should know that if we were
1400 * doing EBUS_IDX_SELFTEST0..EBUS_IDX_SELFTEST7 and we
1401 * had 0x80 set then this is a test error not a retry
1402 * error.
1403 */
1405 }
1406 }
1408 static void
1410 {
1413 }
1414 }
1416 static void
1418 {
1426 /* Bail out things are not working */
1429 /* Didn't manage to map handles so ddi_{get,put}* broken */
1433 }
1435 /* Clear any pending fault */
1439 /* Do the access and get fault code - may take a long time */
1448 /* Things were ok - update cache entry */
1450 /* Store cacheable entries */
1452 }
1454 /* lombus problem - do a resync session */
1458 /* Attempt to resync with the lom */
1460 /*
1461 * Note: we do not set fault status here. That
1462 * is done if our caller decides to give up talking to
1463 * the lom. The observant might notice that this means
1464 * that if we mend things on the last attempt we still
1465 * get the fault set - we just live with that!
1466 */
1467 }
1471 }
1473 static uint8_t
1475 {
1484 /* Bail out things are not working */
1487 /* Didn't manage to map handles so ddi_{get,put}* broken */
1491 }
1493 /* Clear any pending fault */
1497 /* Do the access and get fault code - may take a long time */
1505 /* lombus problem - do a resync session */
1509 /* Attempt to resync with the lom */
1511 /*
1512 * Note: we do not set fault status here. That
1513 * is done if our caller decides to give up talking to
1514 * the lom. The observant might notice that this means
1515 * that if we mend things on the last attempt we still
1516 * get the fault set - we just live with that!
1517 */
1518 }
1519 /*
1520 * FIXME - should report error if you get
1521 * EBUS_ERROR_DEVICEFAIL reported from the BSC. That gets
1522 * logged as a failure in bscv_should_retry and may contribute
1523 * to a permanent failure. Reference issues seen by Mitac.
1524 */
1528 /* Store cacheable entries */
1530 }
1531 }
1536 }
1538 static uint32_t
1540 {
1544 /*
1545 * Failed to map handles, so cannot do any IO. Set the
1546 * fault indicator and return a dummy value.
1547 */
1552 }
1554 /* Clear faults */
1557 /* Probe and Check faults */
1560 /* Read status */
1567 }
1569 static void
1571 {
1577 /*
1578 * Didn't manage to map handles so ddi_{get,put}* broken.
1579 * Therefore, there is no way to resync comms.
1580 */
1584 }
1589 /* Resync here to make sure that the lom is talking */
1592 command_error);
1594 /* Probe */
1597 LOMBUS_PROBE_REG));
1603 "comms resync (probing) - try 0x%x "
1605 }
1606 }
1615 }
1616 }
1618 }
1621 /*
1622 * LOMLite configuration/event eeprom access routines
1623 *
1624 * bscv_window_setup() - Read/Sanity check the eeprom parameters.
1625 * This must be called prior to calling bscv_eerw().
1626 * bscv_eerw() - Read/write data from/to the eeprom.
1627 */
1629 /*
1630 * function - bscv_window_setup
1631 * description - this routine reads the eeprom parameters and sanity
1632 * checks them to ensure that the lom is talking sense.
1633 * inputs - soft state ptr
1634 * outputs - B_TRUE if the eeprom is ok, B_FALSE if the eeprom is not OK.
1635 */
1636 static boolean_t
1638 {
1642 /* Already have good cached values */
1644 }
1648 EBUS_IDX_LOG_START_HI);
1650 /*
1651 * The log does not run to the end of the EEPROM because it is a
1652 * logical partition. The last 8K partition is reserved for FRUID
1653 * usage.
1654 */
1665 /* Sanity check values */
1671 }
1676 }
1678 /*
1679 * function - bscv_eerw
1680 * description - this routine reads/write data from/to the eeprom.
1681 * It takes care of setting the window on the eeprom correctly.
1682 * inputs - soft state ptr, eeprom offset, data buffer, size, read/write
1683 * outputs - B_TRUE if the eeprom is ok, B_FALSE if the eeprom is not OK.
1684 */
1685 static int
1688 {
1702 }
1704 /* Select correct eeprom page */
1720 }
1725 }
1728 }
1730 static boolean_t
1732 {
1737 /*
1738 * This marks a NULL event.
1739 */
1744 /*
1745 * Under some circumstances, we've seen all 1s to represent
1746 * a manually cleared event log at the BSC prompt. Only
1747 * a test/diagnosis environment is likely to show this.
1748 */
1752 /*
1753 * Not a NULL event.
1754 */
1757 }
1758 }
1760 /*
1761 * *********************************************************************
1762 * IOCTL Processing
1763 * *********************************************************************
1764 */
1766 /*
1767 * function - bscv_ioctl
1768 * description - routine that acts as a high level manager for ioctls. It
1769 * calls the appropriate handler for ioctls on the alarm:mon and
1770 * alarm:ctl minor nodes respectively
1771 *
1772 * Unsupported ioctls (now deprecated)
1773 * LOMIOCALCTL
1774 * LOMIOCALSTATE
1775 * LOMIOCCLEARLOG
1776 * LOMIOCCTL
1777 * LOMIOCCTL2
1778 * LOMIOCDAEMON
1779 * LOMIOCDMON
1780 * LOMIOCDOGCTL, TSIOCDOGCTL
1781 * LOMIOCDOGPAT, TSIOCDOGPAT
1782 * LOMIOCDOGTIME, TSIOCDOGTIME
1783 * LOMIOCEVENTLOG
1784 * LOMIOCEVNT
1785 * LOMIOCGETMASK
1786 * LOMIOCMPROG
1787 * LOMIOCNBMON, TSIOCNBMON
1788 * LOMIOCSLEEP
1789 * LOMIOCUNLOCK, TSIOCUNLOCK
1790 * LOMIOCWTMON, TSIOCWTMON
1791 *
1792 * Supported ioctls
1793 * LOMIOCDOGSTATE, TSIOCDOGSTATE
1794 * LOMIOCPROG
1795 * LOMIOCPSUSTATE
1796 * LOMIOCFANSTATE
1797 * LOMIOCFLEDSTATE
1798 * LOMIOCINFO
1799 * LOMIOCMREAD
1800 * LOMIOCVOLTS
1801 * LOMIOCSTATS
1802 * LOMIOCTEMP
1803 * LOMIOCCONS
1804 * LOMIOCEVENTLOG2
1805 * LOMIOCINFO2
1806 * LOMIOCTEST
1807 * LOMIOCMPROG2
1808 * LOMIOCMREAD2
1809 *
1810 * inputs - device number, command, user space arg, filemode, user
1811 * credentials, return value
1812 * outputs - the return value propagated back by the lower level routines.
1813 */
1815 /*ARGSUSED*/
1816 static int
1818 {
1827 }
1829 /*
1830 * The Combined Switch and Service Processor takes care of configuration
1831 * and control. The CSSP tells the BSC chip about it; therefore the
1832 * bscv driver doesn't send such configuration and control to the BSC.
1833 * Additionally Watchdog configuration is no longer done from userland
1834 * lom.
1835 */
1856 }
1858 /*
1859 * set the default result.
1860 */
1869 }
1871 /*
1872 * Check that the caller has appropriate access permissions
1873 * (FWRITE set in mode) for those ioctls which change lom
1874 * state
1875 */
1883 /* NOTREACHED */
1885 /* Does not require write access */
1887 }
1888 }
1963 }
1965 }
1967 /*
1968 * LOMIOCDOGSTATE
1969 * TSIOCDOGSTATE - indicate whether the alarm watchdog and reset
1970 * circuitry is enabled or not.
1971 */
1972 static int
1974 {
1975 lom_dogstate_t dogstate;
1989 }
1991 }
1993 /*
1994 * LOMIOCPSUSTATE - returns full information for 4 PSUs. All this
1995 * information is available from two bytes of LOMlite RAM, but if
1996 * on the first read it is noticed that two or more of the PSUs are
1997 * not present only 1 byte will be read subsequently.
1998 */
1999 static int
2001 {
2002 lom_psudata_t psudata;
2015 }
2020 }
2022 }
2024 /*
2025 * LOMIOCFANSTATE - returns full information including speed for 4
2026 * fans and the minimum and maximum operating speeds for each fan as
2027 * stored in the READ ONLY EEPROM data. As this EEPROM data is set
2028 * at manufacture time, this data should only be read by the driver
2029 * once and stored locally.
2030 */
2031 static int
2033 {
2034 lom_fandata_t fandata;
2048 }
2049 }
2055 }
2057 }
2059 /*
2060 * LOMIOCFLEDSTATE - returns the state of the fault LED
2061 */
2062 static int
2064 {
2065 lom_fled_info_t fled_info;
2071 /* Decode of 0x0F is off and 0x00-0x07 is on. */
2075 /* has +1 here - not 2 as in the info ioctl */
2077 }
2082 }
2084 }
2086 /*
2087 * LOMIOCLEDSTATE - returns the state of the requested LED
2088 */
2089 static int
2091 {
2092 lom_led_state_t led_state;
2096 /* copy in arguments supplied */
2100 }
2102 /*
2103 * check if led index is -1, if so set it to max value for
2104 * this implementation.
2105 */
2108 }
2110 /* is the index in a valid range */
2114 /* read the relevant led info */
2118 /* set the state values accordingly */
2143 }
2145 /* set the label info */
2148 }
2150 /* copy out lom_state */
2155 }
2157 }
2159 /*
2160 * LOMIOCINFO - returns with a structure containing any information
2161 * stored on the LOMlite which a user should not need to access but
2162 * may be useful for diagnostic problems. The structure contains: the
2163 * serial escape character, alarm3 mode, version and checksum read from
2164 * RAM and the Product revision and ID read from EEPROM.
2165 */
2166 static int
2168 {
2169 lom_info_t info;
2187 }
2189 EBUS_ALARM_NOEVENTS) {
2193 }
2199 }
2201 }
2203 /*
2204 * LOMIOCMREAD - used to query the LOMlite configuration parameters
2205 */
2206 static int
2208 {
2209 lom_mprog_t mprog;
2217 }
2223 /* Read the fan calibration values */
2230 }
2236 }
2238 }
2240 /*
2241 * LOMIOCVOLTS
2242 */
2243 static int
2245 {
2256 }
2262 }
2264 }
2266 /*
2267 * LOMIOCSTATS
2268 */
2269 static int
2271 {
2280 }
2286 }
2288 }
2290 /*
2291 * LOMIOCTEMP
2292 */
2293 static int
2295 {
2299 lom_temp_t temps;
2311 idx++;
2312 }
2313 }
2322 }
2328 }
2330 }
2332 /*
2333 * LOMIOCCONS
2334 */
2335 static int
2337 {
2338 lom_cbuf_t cbuf;
2344 /* Ensure that we do not overfill cbuf and that it is NUL terminated */
2347 }
2351 /* This is always within the array due to the checks above */
2358 }
2360 }
2362 /*
2363 * LOMIOCEVENTLOG2
2364 */
2365 static int
2367 {
2372 lom_event_t event;
2376 KM_SLEEP);
2378 /*
2379 * First get number of events and level requested.
2380 */
2386 }
2390 /*
2391 * OK we have full private access to the LOM now so loop
2392 * over the eventlog addr spaces until we get the required
2393 * number of events.
2394 */
2401 }
2403 /*
2404 * Read count, next event ptr MSB,LSB. Note a read of count
2405 * is necessary to latch values for the next event ptr
2406 */
2410 next_offset);
2415 /*
2416 * Working backwards - read an event at a time.
2417 * next_offset is one event on from where we want to be!
2418 * Decrement next_offset and maybe wrap to the end of the
2419 * buffer.
2420 * Note the unsigned arithmetic, so check values first!
2421 */
2423 /* Wrap to the end of the buffer */
2427 next_offset);
2428 }
2433 /* Fault reading data - stop */
2438 }
2441 /*
2442 * No more events in this log so give up.
2443 */
2447 }
2449 /*
2450 * Are we interested in this event
2451 */
2455 /* Arggh why the funny byte ordering 3, 2, 0, 1 */
2472 events_recorded++;
2473 }
2474 }
2484 }
2488 }
2490 /*
2491 * LOMIOCINFO2
2492 */
2493 static int
2495 {
2496 lom2_info_t info2;
2518 }
2522 EBUS_CONFIG_MISC_SECURITY_ENABLED) {
2524 }
2526 EBUS_CONFIG_MISC_AUTO_CONSOLE) {
2528 }
2530 EBUS_WDOG_BREAK_DISABLE) {
2532 }
2543 /*
2544 * There is no phone home support on the blade platform. We hardcode
2545 * FALSE and NUL for config and script respectively.
2546 */
2552 }
2558 }
2560 }
2562 /*
2563 * LOMIOCTEST
2564 */
2565 static int
2567 {
2576 }
2578 /*
2579 * Extract num iterations.
2580 */
2591 /* Invalid test */
2603 /* Run the test */
2605 /* Stop other things and then run the test */
2608 /*
2609 * Then we simply write the argument to the relevant register
2610 * and wait for the return code.
2611 */
2617 /* Get hold of the SunVTS error code */
2619 }
2623 }
2631 }
2633 }
2635 /*
2636 * LOMIOCMPROG2
2637 */
2638 static int
2640 {
2641 lom2_mprog_t mprog2;
2650 }
2652 /*
2653 * Note that originally this was accessed as 255 byte pages
2654 * in address spaces 240-255. We have to emulate this behaviour.
2655 */
2658 }
2662 /* Calculate required data location */
2677 }
2684 }
2691 }
2696 }
2698 /* Read a probe key to release the lock. */
2703 }
2707 }
2709 /*
2710 * LOMIOCMREAD2
2711 */
2712 static int
2714 {
2715 lom2_mprog_t mprog2;
2724 }
2726 /*
2727 * Need to stop the queue and then just read
2728 * the bytes blind to the relevant addresses.
2729 * Note that originally this was accessed as 255 byte pages
2730 * in address spaces 240-255. We have to emulate this behaviour.
2731 */
2734 }
2738 /* Calculate required data location */
2752 }
2757 }
2761 }
2768 }
2770 }
2772 static void
2774 {
2782 /* Are there any changes to process? */
2788 /* Clarify the pending change */
2792 }
2796 }
2798 /*
2799 * *********************************************************************
2800 * Event Processing
2801 * *********************************************************************
2802 */
2804 /*
2805 * function - bscv_event_daemon
2806 * description - Perform periodic lom tasks in a separate thread.
2807 * inputs - LOM soft state structure pointer
2808 * outputs - none.
2809 */
2810 static void
2812 {
2814 boolean_t do_events;
2815 boolean_t do_status;
2816 boolean_t do_nodename;
2817 boolean_t do_watchdog;
2826 /* Acquire task daemon lock. */
2833 /* Stop request seen - terminate */
2835 }
2837 /* Poll for events reported to the nexus */
2839 /* Probe and Check faults */
2847 /* Treat non-fault conditions */
2850 /*
2851 * The BSC has become available again.
2852 */
2858 /* Previous fault has cleared */
2862 "!bscv_event_daemon previous fault "
2865 /* Previous fault has cleared */
2867 /* Sleep to avoid busy waiting */
2869 }
2875 }
2877 /*
2878 * Expect radio silence or error values
2879 * when the CSSP is upgrading the BSC firmware
2880 * so throw away any fault indication.
2881 */
2884 /* Count previous faults and maybe fail */
2885 /* Declare the lom broken */
2889 "!bscv_event_daemon had faults probing "
2891 /*
2892 * Increment fault_cnt to ensure that
2893 * next time we do not report a message
2894 * i.e. we drop out of the bottom
2895 */
2901 /*
2902 * No recovery messages in this case
2903 * because there was never a fault
2904 * message here.
2905 */
2908 /* Getting ready to explode */
2909 fault_cnt++;
2912 fault);
2913 }
2915 }
2918 }
2920 #if defined(__i386) || defined(__amd64)
2921 /*
2922 * we have no platmod hook on Solaris x86 to report
2923 * a change to the nodename so we keep a copy so
2924 * we can detect a change and request that the bsc
2925 * be updated when appropriate.
2926 */
2935 /* enforce null termination */
2938 }
2957 }
2960 /*
2961 * We must not hold task_mu whilst processing
2962 * events because this can lead to priority
2963 * inversion and hence our interrupts getting
2964 * locked out.
2965 */
2969 }
2974 }
2979 }
2980 /*
2981 * Pending status changes are dealt with last because
2982 * if we see that the BSC is about to be programmed,
2983 * then it will expect us to to quiescent in the
2984 * first second so it can cleanly tear down its comms
2985 * protocols; this takes ~100 ms.
2986 */
2989 }
2991 /*
2992 * Had fault during event session. We always
2993 * sleep after one of these because there
2994 * may be a problem with the lom which stops
2995 * us doing useful work in the event daemon.
2996 * If we don't sleep then we may livelock.
2997 */
3001 }
3007 /*
3008 * We have read any events which were
3009 * pending. Let the consumer continue.
3010 * Ignore the race condition with new events
3011 * arriving - just let the consumer have
3012 * whatever was pending when they asked.
3013 */
3016 TASK_EVENT_CONSUMER_FLG);
3018 }
3020 /* There was nothing to do - sleep */
3022 }
3026 /* Sleep until there is something to do */
3031 }
3032 }
3035 /*
3036 * We are going away so wake up any event consumer.
3037 * Pretend that any pending events have been processed.
3038 */
3041 }
3050 }
3052 /*
3053 * function - bscv_start_event_daemon
3054 * description - Create the event daemon thread.
3055 * inputs - LOM soft state structure pointer
3056 * outputs - none
3057 */
3058 static void
3060 {
3064 /* Start the event thread after the queue has started */
3069 }
3071 /*
3072 * function - bscv_stop_event_daemon
3073 * description - Attempt to stop the event daemon thread.
3074 * inputs - LOM soft state structure pointer
3075 * outputs - DDI_SUCCESS OR DDI_FAILURE
3076 */
3077 static int
3079 {
3085 /* Wait for task daemon to stop running. */
3089 /* Signal that the task daemon should stop */
3092 /* Release task daemon lock. */
3094 /*
3095 * TODO - when the driver is modified to support
3096 * system suspend or if this routine gets called
3097 * during panic we should use drv_usecwait() rather
3098 * than delay in those circumstances.
3099 */
3102 }
3106 }
3110 }
3112 /*
3113 * function - bscv_pause_event_daemon
3114 * description - Attempt to pause the event daemon thread.
3115 * inputs - LOM soft state structure pointer
3116 * outputs - DDI_SUCCESS OR DDI_FAILURE
3117 */
3118 static int
3120 {
3124 /* Nothing to do */
3126 }
3132 /* Signal that the task daemon should pause */
3135 /* Wait for task daemon to pause. */
3141 /* Paranoia */
3144 /* Release task daemon lock. */
3148 }
3155 }
3160 }
3162 /*
3163 * function - bscv_resume_event_daemon
3164 * description - Resumethe event daemon thread.
3165 * inputs - LOM soft state structure pointer
3166 * outputs - None.
3167 */
3168 static void
3170 {
3172 /* Nothing to do */
3174 }
3177 /* Allow the task daemon to resume event processing */
3184 }
3186 /*
3187 * function - bscv_event_process
3188 * description - process (report) events
3189 * inputs - Soft state ptr, process event request
3190 * outputs - none
3191 */
3192 static void
3194 {
3198 /* Raw values read from the lom */
3202 lom_event_t event;
3205 /*
3206 * Read count, next event ptr MSB,LSB. Note a read of count
3207 * latches values for the next event ptr
3208 */
3212 /* Sanity check the values from the lom */
3216 /*
3217 * Nothing to do - or badly configured event log.
3218 * We really do not want to touch the lom in this
3219 * case because any data that we access may be bad!
3220 * This differs from zero because if we have zero
3221 * to read the lom probably things that unread is
3222 * non-zero and we want that to be set to zero!
3223 * Signal event fault to make the thread wait
3224 * before attempting to re-read the log.
3225 */
3229 }
3231 /* Clear down any old status - things are fixed */
3234 }
3236 /* Compute the first entry that we need to read. */
3250 /* Ensure window is positioned correctly */
3253 /* Fault reading data - stop */
3255 }
3264 }
3265 }
3266 /*
3267 * Clear event count - write the evcount value to remove that
3268 * many from the unread total.
3269 * Adjust the value to reflect how many we have left to
3270 * read just in case we had a failure reading events.
3271 */
3273 /*EMPTY*/
3279 }
3281 /* Remember where we were for next time */
3284 logdone:
3285 ;
3286 }
3287 }
3289 /*
3290 * function - bscv_event_validate
3291 * description - validate the event data supplied by the lom and determine
3292 * how many (if any) events to read.
3293 * This function performs complex checks to ensure that
3294 * events are not lost due to lom resets or host resets.
3295 * A combination of lom reset and host reset (i.e. power fail)
3296 * may cause some events to not be reported.
3297 * inputs - Soft state ptr, next event pointer, number of unread events.
3298 * outputs - the number of events to read. -1 on error.
3299 * zero is a valid value because it forces the loms unread
3300 * count to be cleared.
3301 */
3302 static int
3304 {
3309 /* Problem with lom eeprom setup we cannot do anything */
3311 }
3313 /* Sanity check the event pointers */
3320 }
3322 }
3324 /* Now sanity check log pointer against count */
3326 /*
3327 * Must have wrapped add eventlog_size to get the
3328 * correct relative values - this makes the checks
3329 * below work!
3330 */
3332 }
3334 /* We have just started up - we have to trust lom */
3337 /* Nothing to do - we were just polling */
3340 /* Ok - got as many events as we expected */
3343 /*
3344 * Errrm more messages than there should have been.
3345 * Possible causes:
3346 * 1. the event log has filled - we have been
3347 * away for a long time
3348 * 2. software bug in lom or driver.
3349 * 3. something that I haven't thought of!
3350 * Always warn about this we should really never
3351 * see it!
3352 */
3355 "bscv_event_process: lom reported "
3360 /* Less messages - perhaps the lom has been reset */
3363 "lom reported less events (%d) than expected (%d)"
3366 }
3367 /* Whatever happens only read a maximum of 255 entries */
3370 "bscv_event_process: too many events (%d) to "
3373 }
3375 }
3377 /*
3378 * function - bscv_event_process_one
3379 * description - reports on state changes to the host.
3380 *
3381 * inputs - LOM soft state structure pointer.
3382 *
3383 * outputs - none.
3384 */
3386 static void
3388 {
3394 /* Cleared entry - do not report it */
3396 }
3409 }
3415 /*
3416 * The message is important enough to be shown on the console
3417 * as well as the log.
3418 */
3421 /*
3422 * The message goes only to the log.
3423 */
3425 }
3426 }
3428 /*
3429 * time formats
3430 *
3431 * The BSC represents times as seconds since epoch 1970. Currently it gives
3432 * us 32 bits, unsigned. In the future this might change to a 64-bit count,
3433 * to allow a greater range.
3434 *
3435 * Timestamp values below BSC_TIME_SANITY do not represent an absolute time,
3436 * but instead represent an offset from the last reset. This must be
3437 * borne in mind by output routines.
3438 */
3442 #define BSC_TIME_SANITY 1000000000
3444 /*
3445 * render a formatted time for display
3446 */
3448 static size_t
3450 {
3453 /* tod_year is base 1900 so this code needs to adjust */
3459 }
3461 /*
3462 * function - bscv_build_eventstring
3463 * description - reports on state changes to the host.
3464 *
3465 * inputs - LOM soft state structure pointer.
3466 *
3467 * outputs - none.
3468 */
3470 static void
3473 {
3476 bsctime_t bsctm;
3485 /*
3486 * We accept bad subsystems and event type codes here.
3487 * The code decodes as much as possible and then produces
3488 * suitable output.
3489 */
3493 /* time */
3499 /* offset */
3504 /* absolute time */
3509 }
3512 /* subsysp */
3520 }
3522 /* resource */
3539 }
3541 /* fatal */
3547 }
3548 }
3550 /* eventp */
3560 }
3562 /* detail */
3569 }
3575 }
3593 LOM_UNEXPECTEDRESET_MASK_BADTRAP) {
3598 }
3613 }
3617 }
3644 }
3659 }
3669 /*
3670 * If both inputs are seen to have failed then simply
3671 * indicate that the PSU input has failed
3672 */
3677 /* At least one input is ok */
3681 }
3685 }
3686 /*
3687 * Only flag an output error if an input is
3688 * still present
3689 */
3693 }
3694 }
3696 }
3711 }
3712 }
3736 }
3737 }
3750 }
3751 }
3756 }
3758 /* shutd */
3761 }
3766 /* Ensure newline at end of string */
3769 #ifdef DEBUG
3772 }
3773 }
3775 /*
3776 * function - bscv_level_of_event
3777 * description - This routine determines which level an event should be
3778 * reported at.
3779 * inputs - lom event structure pointer
3780 * outputs - event level.
3781 */
3782 static int
3784 {
3786 /*
3787 * This is the same criteria that the firmware uses except we
3788 * log the fault led on as being EVENT_LEVEL_FAULT
3789 */
3796 EVENT_SUBSYS_NONE) &&
3804 /*
3805 * All recovery messages need to be reported to the console
3806 * because during boot, the faults which occurred whilst
3807 * Solaris was not running are relayed to the console. There
3808 * is a case whereby a fatal fault (eg. over temp) could
3809 * have occurred and then recovered. The recovery condition
3810 * needs to be reported so the user doesn't think that the
3811 * failure (over temp) is still present.
3812 */
3815 /* None of FAULT, FATAL or SHUTDOWN REQD are set */
3818 /* Only FAULT set i.e not FATAL or SHUTDOWN REQD */
3822 }
3825 }
3827 /*
3828 * function - bscv_status
3829 * description - This routine is called when any change in the LOMlite2 status
3830 * is indicated by the status registers.
3831 *
3832 * inputs - LOM soft state structure pointer
3833 *
3834 * outputs - none.
3835 */
3836 static void
3838 {
3847 /*
3848 * The device that has changed is given by the state change
3849 * register and the event detail register so react
3850 * accordingly.
3851 */
3854 /*
3855 * The BSC is indicating a self state change
3856 */
3862 /*
3863 * It takes the BSC at least 100 ms to
3864 * clear down the comms protocol.
3865 * We back-off from talking to the
3866 * BSC during this period.
3867 */
3872 /*
3873 * The bsc has reset
3874 */
3880 }
3882 }
3887 /*
3888 * Only remember fanspeeds which are real values or
3889 * NOT PRESENT values.
3890 */
3894 }
3895 }
3900 }
3904 }
3908 }
3914 /*
3915 * Only remember temperatures which are real values or
3916 * a NOT PRESENT value.
3917 */
3921 }
3922 }
3927 }
3928 }
3932 {
3941 }
3943 static void
3946 {
3958 }
3964 }
3970 }
3976 }
3982 }
3988 }
3994 }
4003 }
4006 }
4008 /*
4009 * function - bscv_sysevent
4010 * description - send out a sysevent on the given change if needed
4011 * inputs - soft state pointer, event to report
4012 * outputs - none
4013 */
4015 static void
4017 {
4028 /* Map ev_subsys to sysevent class/sub-class */
4051 }
4068 }
4083 }
4105 /*
4106 * There are 3 LEDs : Power, Service, Ready-to-Remove on a
4107 * JBOS blade. We'll never report the Power since Solaris
4108 * won't be running when it is _switched_ ON. Ready-to-Remove
4109 * will only be lit when we're powered down which also means
4110 * Solaris won't be running. We don't want to report it
4111 * during system testing / Sun VTS exercising the LEDs.
4112 *
4113 * Therefore, we only report the Service Required LED.
4114 */
4142 }
4146 }
4151 }
4154 ENV_RESERVED_ATTR);
4155 }
4157 /*
4158 * *********************************************************************
4159 * Firmware download (programming)
4160 * *********************************************************************
4161 */
4163 /*
4164 * function - bscv_prog
4165 * description - LOMlite2 flash programming code.
4166 *
4167 * bscv_prog_image - download a complete image to the lom.
4168 * bscv_prog_receive_image - receive data to build up a
4169 * complete image.
4170 * bscv_prog_stop_lom - pause the event daemon and prepare
4171 * lom for firmware upgrade.
4172 * bscv_prog_start_lom - reinit the driver/lom after upgrade
4173 * and restart the event daemon
4174 *
4175 * inputs - soft state pointer, arg ptr, ioctl mode
4176 * outputs - status
4177 */
4179 static int
4181 {
4185 /*
4186 * We will get repeatedly called with bits of data first for
4187 * loader, then for main image.
4188 */
4195 }
4203 /*
4204 * This is the initial request for the chip type so we
4205 * know what we are programming.
4206 * The type will have been read in at init so just
4207 * return it in data[0].
4208 */
4210 EBUS_IDX_CPU_IDENT);
4215 }
4222 }
4227 }
4230 }
4235 }
4237 static int
4239 {
4244 /*
4245 * loader_running TRUE means that we have told the microcontroller to
4246 * JUMP into the loader code which has been downloaded into its RAM.
4247 * At this point its an error to try and download another loader. We
4248 * should be downloading the actual image at this point.
4249 * Conversely, it is an error to download an image when the loader is
4250 * not already downloaded and the microcontroller hasn't JUMPed into it.
4251 * is_image2 TRUE means the image is being downloaded.
4252 * is_image2 FALSE means the loader is being downloaded.
4253 */
4265 }
4268 }
4270 static uint32_t
4272 {
4283 }
4285 /*
4286 * Sets the pagesize, returning the old value.
4287 */
4288 static uint32_t
4290 {
4297 /*
4298 * The microcontroller remembers this value until until someone
4299 * changes it.
4300 */
4305 }
4307 static uint8_t
4309 {
4316 EBUS_PROGRAM_PCR_PRGMODE_ON);
4319 EBUS_PROGRAM_PCSR));
4322 }
4324 static void
4326 {
4338 }
4342 }
4345 static void
4347 {
4355 }
4357 static uint8_t
4359 {
4364 /*
4365 * write PADR, PSIZ to define area to be erased
4366 * We do not send erase for zero size because the current
4367 * downloader gets this wrong
4368 */
4370 /*
4371 * start at 0
4372 */
4377 loadaddr);
4379 /* set PSIZ to full size of image to be programmed */
4382 image_size);
4384 /* write ERASE to PCSR */
4387 EBUS_PROGRAM_PCR_ERASE);
4389 /* read PCSR to check status */
4393 }
4395 static uint8_t
4397 boolean_t is_image2)
4398 {
4406 else
4412 }
4415 }
4417 static uint8_t
4419 {
4427 /*
4428 * Write the page address and read it back for confirmation.
4429 */
4432 addr);
4443 }
4444 }
4446 EBUS_PROGRAM_PSR_INVALID_OPERATION);
4447 }
4449 static uint8_t
4453 {
4463 /* write PSIZ bytes to PDAT */
4477 /* Now pad the rest of the page with zeros */
4481 EBUS_PROGRAM_DATA),
4483 }
4484 }
4486 /* write the checksum to PCSM */
4491 }
4492 /* Cope with non-pagesize sized bufers */
4495 }
4501 EBUS_PROGRAM_PCR_PROGRAM);
4508 }
4512 boolean_t is_image2)
4513 {
4521 /*
4522 * Set the page address (with retries). If this is not
4523 * successful, then there is no point carrying on and sending
4524 * the page's data since that could cause random memory
4525 * corruption in the microcontroller.
4526 */
4534 }
4536 /*
4537 * Send down the data for the page
4538 */
4546 else
4551 }
4558 }
4560 static uint8_t
4563 {
4576 }
4577 }
4580 }
4582 static int
4585 {
4595 /*
4596 * Return no error to allow userland to continue on with
4597 * downloading the image.
4598 */
4611 }
4614 /*
4615 * Only issue an erase if we are downloading the image. The loader
4616 * does not need this step.
4617 */
4623 retval);
4630 }
4631 }
4636 is_image2);
4642 }
4644 BSCV_PROG_IMAGE_END:
4646 /*
4647 * We've downloaded the loader successfully. Now make the
4648 * microcontroller jump to it.
4649 */
4654 /*
4655 * We've just downloaded either the loader which failed, or
4656 * the image (which may or may not have been successful).
4657 */
4663 res);
4669 }
4673 }
4678 }
4681 static int
4684 {
4686 uint_t size;
4695 }
4697 /*
4698 * We want to get the whole image and then do the download.
4699 * It is assumed the device is now in programming mode.
4700 */
4703 /* Starting a new image */
4705 }
4712 }
4719 /*
4720 * OK we have the whole image so synch up and start download.
4721 */
4724 /* Old style programming data */
4725 /* Take care image may not fill all of structure */
4727 /* sign extend loadaddr from 16 to 32 bits */
4736 }
4742 /*
4743 * Done the loading so set the flag to say we are doing
4744 * the other image.
4745 */
4750 /* Image too small for new style image */
4754 /* New style programming image */
4775 }
4776 }
4779 }
4781 }
4783 static int
4785 {
4787 /*
4788 * Already programming - this may be a retry of a failed
4789 * programming attempt or just a software error!
4790 */
4792 }
4798 }
4806 queue_stopped:
4812 }
4814 static int
4816 {
4820 /* Not programming so this is not a valid command */
4822 }
4827 }
4829 /*
4830 * OK we are out of reset now so:
4831 * Probe the firmware and set everything up.
4832 */
4836 /* Explicit clear fault because things may have been mended now */
4842 /* Must try to restart the lom here. */
4843 /* Ensure prog mode entry to enable PRGMODE_OFF */
4846 EBUS_PROGRAM_PCR_PRGMODE_ON);
4849 EBUS_PROGRAM_PCR_PRGMODE_OFF);
4851 /* give the lom chance to recover */
4853 }
4861 }
4866 /*
4867 * Start the event thread after the queue has started
4868 *
4869 * Not sure if this is entirely correct because
4870 * the other code at the end of bscv_attach()
4871 * does not get run here.
4872 */
4875 }
4878 }
4881 /*
4882 * *********************************************************************
4883 * Attach processing
4884 * *********************************************************************
4885 */
4887 /*
4888 * function - bscv_attach_common
4889 * description - this routine co-ordinates the initialisation of the
4890 * driver both at attach time and after firmware programming.
4891 * sequence - bscv_setup_capability - read LOMlite2 capabilities
4892 * bscv_probe_check - test comms and setup register cache
4893 * bscv_setup_hostname - sync stored name in lom with nodename.
4894 * bscv_setup_static_info - read device names etc.
4895 * bscv_setup_events - start event daemon etc.
4896 *
4897 * inputs - device information structure, DDI_ATTACH command
4898 * outputs - DDI_SUCCESS or DDI_FAILURE
4899 */
4901 static int
4903 {
4908 /*
4909 * Set the threshold for reporting messages to the console to
4910 * Warnings or higher.
4911 */
4914 /*
4915 * When the system is not running the Operating System, make
4916 * the microcontroller print event messages straight onto the
4917 * console.
4918 */
4921 /* Setup capabilities */
4926 /*
4927 * We want lom -G to talk to this driver upon broken firmware
4928 * so we prematurely return success here.
4929 */
4931 }
4937 #if defined(__i386) || defined(__amd64)
4940 /*
4941 * Watchdog configuration and CPU signatures are sent asynchronously
4942 * with respect to attach so only inform the BSC if we've already
4943 * sent the data in the past.
4944 */
4951 }
4953 /*
4954 * function - bscv_cleanup
4955 * description - routine that does the necessary tidying up if the attach
4956 * request fails or the driver is to be detached.
4957 * If the event thread has been started we may fail to
4958 * stop it (because it is busy) so we fail the cleanup
4959 * and hence the detach. All other calls to bscv_cleanup
4960 * are done before the event daemon is started.
4961 * inputs - soft state structure address.
4962 * outputs - DDI_SUCCESS or DDI_FAILURE.
4963 */
4965 static int
4967 {
4976 }
4980 /* Fail the cleanup - may be able to cleanup later */
4983 }
4985 }
4986 }
4990 }
4993 /*
4994 * switch back on serial event reporting - cover all configs.
4995 */
5004 }
5008 /*
5009 * disable the reset function if we have enabled
5010 * it. We don't want any nasty surprises like system
5011 * rebooting unexpectedly. If we timeout on the busy
5012 * flag we just have to carry on.
5013 */
5018 EBUS_WDOG_ENABLE) {
5021 }
5022 }
5024 /*
5025 * unmap registers
5026 */
5030 }
5032 /*
5033 * release any memory allocated for mutexes and condition
5034 * variables before deallocating the structures containing them
5035 */
5044 }
5048 }
5050 #if defined(__i386) || defined(__amd64)
5056 }
5058 /*
5059 * function - bscv_setup_capability
5060 * description - probe the lom find what capabilities are present for
5061 * us to use.
5062 * inputs - soft state ptr
5063 * outputs - returns DDI_SUCCESS or DDI_FAILURE
5064 */
5066 {
5070 /* Turn off all capabilities */
5075 }
5087 }
5088 }
5090 /*
5091 * function - bscv_probe_check
5092 * description - probe the lom to check for correct operation
5093 * has a side effect of setting up the cached registers and
5094 * updates ssp->prog_mode_only.
5095 * inputs - soft state ptr
5096 * outputs - returns DDI_SUCCESS or DDI_FAILURE
5097 */
5100 {
5109 /*
5110 * Make sure probe location is OK so that we are
5111 * in sync.
5112 * We want to make sure that this is not faulty so we
5113 * do a bscv_clear_fault to clear any existing
5114 * fault records down.
5115 */
5124 /*
5125 * It may be that the LOMlite was out of
5126 * sync so lets try the read again.
5127 */
5129 EBUS_IDX_PROBEAA);
5135 /*
5136 * OK that is twice we are out so I
5137 * guess the LOMlite is in trouble
5138 */
5141 probeval);
5143 }
5144 }
5145 }
5147 /*
5148 * Read in all page zero lom registers.
5149 * Read state change 1st so we dont miss anything and clear it.
5150 * Note: we discard the values because we rely on bscv_get8 to
5151 * setup the cache of register values.
5152 */
5160 }
5161 }
5169 /*
5170 * Should not read these - they have side
5171 * effects.
5172 */
5177 }
5182 /* Might as well give up now! */
5184 }
5185 }
5186 }
5188 /*
5189 * Check the probe keys so we know the lom is OK
5190 */
5200 "%2x %2x %2x %2x %2x %2x %2x %2x %2x "
5218 }
5220 }
5221 }
5224 }
5227 static void
5229 {
5232 /*
5233 * The value of the dog pat is a sequence number which wraps around,
5234 * bounded by BSCV_WDOG_PAT_SEQ_MASK.
5235 */
5239 /* Set top nibble to indicate a pat */
5242 /*
5243 * Now pat the dog. This exercises a special protocol in the
5244 * bus nexus that offers : non-blocking IO, and timely delivery,
5245 * callable from high-level interrupt context. The requirement
5246 * on us is that the channel is not shared for any other use.
5247 * This means for chan_wdogpat, nothing may use channel[chan].regs
5248 * or channel.[chan].handle.
5249 */
5255 pat);
5256 }
5259 static void
5261 uint_t wdog_timeout_s,
5262 boolean_t enable_wdog,
5264 {
5267 /*
5268 * Configure the timeout value (1 to 127 seconds).
5269 * Note that a policy is implemented at the bsc/ssp which bounds
5270 * the value further. The bounding here is to fit the timeout value
5271 * into the 7 bits the bsc uses.
5272 */
5277 else
5280 /*
5281 * Configure the watchdog on or off.
5282 */
5285 else
5288 /*
5289 * Configure whether the microcontroller should reset the system when
5290 * the watchdog expires.
5291 */
5297 /* have the event daemon set the timeout value and whether to reset */
5302 }
5304 /*
5305 * function - bscv_setup_watchdog
5306 * description - setup the bsc watchdog
5307 * inputs - soft state ptr
5308 * outputs -
5309 */
5311 {
5317 /* Set the timeout */
5321 /* Set whether to reset the system on timeout */
5326 }
5332 }
5334 /* Set other host defaults */
5341 #if defined(__i386) || defined(__amd64)
5342 /* start the cyclic based watchdog patter */
5346 }
5349 /*
5350 * function - bscv_setup_hostname
5351 * description - setup the lom hostname if different from the nodename
5352 * inputs - soft state ptr
5353 * outputs - none
5354 */
5357 {
5365 /*
5366 * Check machine label is the same as the
5367 * system nodename.
5368 */
5372 /* read in lom hostname */
5375 /* Enforce null termination */
5389 /* Write new label into LOM EEPROM */
5391 host_nodename,
5393 }
5396 }
5398 /*
5399 * function - bscv_read_hostname
5400 * description - read the current hostname from the lom
5401 * inputs - soft state pointer and buffer to store the hostname in.
5402 * outputs - none
5403 */
5405 static void
5407 {
5409 boolean_t needretry;
5415 /*
5416 * We have a special failure case here because a retry of a read
5417 * causes data to be lost. Thus we handle the retries ourselves
5418 * and are also responsible for detemining if the lom is faulty
5419 */
5422 num_failures++) {
5432 /* Retry on any error */
5436 }
5437 }
5438 /* null terminate for strcmp later */
5440 }
5443 }
5444 /* Force the nodename to be empty */
5446 }
5449 /* Failure - we ran out of retries */
5452 num_failures);
5457 }
5458 }
5460 /*
5461 * function - bscv_write_hostname
5462 * description - write a new hostname to the lom
5463 * inputs - soft state pointer, pointer to new name, name length
5464 * outputs - none
5465 */
5466 static void
5469 {
5471 boolean_t needretry;
5476 /*
5477 * We have a special failure case here because a retry of a read
5478 * causes data to be lost. Thus we handle the retries ourselves
5479 * and are also responsible for detemining if the lom is faulty
5480 */
5483 num_failures++) {
5493 /* Retry on any error */
5497 }
5498 }
5499 }
5502 }
5503 }
5506 /* Failure - we ran out of retries */
5509 num_failures);
5514 }
5515 }
5517 /*
5518 * function - bscv_setup_static_info
5519 * description - read in static information from the lom at attach time.
5520 * inputs - soft state ptr
5521 * outputs - none
5522 */
5524 static void
5526 {
5536 /*
5537 * Finally read in some static info like device names,
5538 * shutdown enabled, etc before the queue starts.
5539 */
5541 /*
5542 * To get the volts static info we need address space 2
5543 */
5553 }
5558 EBUS_CMD_SPACE2,
5559 EBUS_IDX2_SUPPLY_NAME_START,
5560 EBUS_IDX2_SUPPLY_NAME_END,
5567 EBUS_IDX2_SUPPLY_FATAL_MASK2));
5572 }
5574 /*
5575 * Get the temperature static info and populate initial temperatures.
5576 * Do not destroy old temperature values if the new value is not
5577 * known i.e. if the device is inaccessible.
5578 */
5586 "lom: firmware reported too many temperatures being "
5591 }
5596 "lom: firmware reported too many over temperatures being "
5601 }
5607 EBUS_CMD_SPACE4,
5608 EBUS_IDX4_TEMP_NAME_START,
5609 EBUS_IDX4_TEMP_NAME_END,
5617 /*
5618 * If shutdown is not enabled then set it as zero so
5619 * it is not displayed by the utility.
5620 */
5624 chan_general,
5628 }
5629 }
5637 /* New value is not known - use old value */
5639 }
5640 }
5642 /*
5643 * Check for and skip a single 0xff character between the
5644 * temperature and over temperature names
5645 */
5648 addr_space_ptr++;
5649 }
5652 EBUS_CMD_SPACE4,
5653 addr_space_ptr,
5654 EBUS_IDX4_TEMP_NAME_END,
5658 /*
5659 * To get the CB static info we need address space 3
5660 */
5671 }
5676 EBUS_CMD_SPACE3,
5677 EBUS_IDX3_BREAKER_NAME_START,
5678 EBUS_IDX3_BREAKER_NAME_END,
5683 /*
5684 * To get the fan static info we need address space 5
5685 */
5695 }
5702 /*
5703 * Do not destroy previous values unless the
5704 * value is definitive.
5705 */
5707 }
5708 }
5714 EBUS_CMD_SPACE5,
5715 EBUS_IDX5_FAN_NAME_START,
5716 EBUS_IDX5_FAN_NAME_END,
5720 /* Get led static information from address space 10 */
5723 EBUS_CMD_SPACE_LEDS,
5724 EBUS_IDX10_LED_NAME_START,
5725 EBUS_IDX10_LED_NAME_END,
5727 MAX_LED_ID);
5728 }
5730 /*
5731 * function - bscv_read_env_name
5732 * description - read in static environment names
5733 * warning changes address space and the caller relies
5734 * on this behaviour.
5735 * inputs - soft state ptr, chosen address space,
5736 * start of name data, end of name data,
5737 * name storage, number of names.
5738 * outputs - next address for reading name data.
5739 */
5741 static uint8_t
5748 {
5769 /*
5770 * Read the current character.
5771 */
5776 /*
5777 * Ran out of names - this must
5778 * be the end of the name.
5779 * This is really an error because
5780 * we have just seen either a non-NUL
5781 * terminated string or the number of
5782 * strings did not match what was
5783 * reported.
5784 */
5786 }
5787 /*
5788 * We increment the buffer pointer now so that
5789 * it is ready for the next read
5790 */
5791 addr_space_ptr++;
5794 /* Found end of string - done */
5796 }
5798 /*
5799 * Buffer not full - record character
5800 * NOTE we always leave room for the NUL
5801 * terminator.
5802 */
5804 }
5805 }
5806 /* Ensure null termination */
5808 }
5809 /* Clamp addr_space_ptr to 0xff because we return uint8_t */
5812 }
5814 }
5816 /*
5817 * function - bscv_setup_events
5818 * description - initialise the event reporting code
5819 * inputs - soft state ptr
5820 * outputs - DDI_SUCCESS or DDI_FAILURE
5821 */
5823 static void
5825 {
5831 /*
5832 * deal with event reporting - cover all cases
5833 */
5843 }
5846 }
5849 #if defined(__i386) || defined(__amd64)
5851 /*
5852 * function - bscv_inform_bsc
5853 * description - inform bsc of driver state for logging purposes
5854 * inputs - driver soft state, state
5855 * outputs - none
5856 *
5857 */
5858 static void
5860 {
5870 }
5872 /*
5873 * function - bscv_watchdog_pat_request
5874 * description - request a heartbeat pat
5875 * inputs - timeout value in seconds
5876 * outputs - none
5877 */
5878 static void
5880 {
5884 }
5886 /*
5887 * function - bscv_watchdog_cfg_request
5888 * description - request configuration of the bsc hardware watchdog
5889 * inputs - new state (0=disabled, 1=enabled)
5890 * outputs - one if successful, zero if unsuccesful
5891 */
5892 static void
5894 {
5901 bscv_watchdog_timeout_seconds,
5902 new_state,
5903 wdog_reset_on_timeout);
5904 }
5906 /*
5907 * function - bscv_set_watchdog_timer
5908 * description - setup the heartbeat timeout value
5909 * inputs - timeout value in seconds
5910 * outputs - zero if the value was not changed
5911 * otherwise the current value
5912 */
5913 static uint_t
5915 {
5919 /*
5920 * We get started during bscv_attach only
5921 * if bscv_watchdog_enable is set.
5922 */
5929 }
5931 }
5933 /*
5934 * function - bscv_clear_watchdog_timer
5935 * description - add the watchdog patter cyclic
5936 * inputs - driver soft state
5937 * outputs - value of watchdog timeout in seconds
5938 *
5939 * This function is a copy of the SPARC implementation
5940 * in the todblade clock driver.
5941 */
5942 static void
5944 {
5950 }
5951 }
5953 /*
5954 * function - bscv_panic_callback
5955 * description - called when we panic so we can disabled the watchdog
5956 * inputs - driver soft state pointer
5957 * outputs - DDI_SUCCESS
5958 */
5959 /*ARGSUSED1*/
5960 static boolean_t
5962 {
5969 /*
5970 * We dont get interrupts during the panic callback. But bscbus
5971 * takes care of all this
5972 */
5975 }
5977 /*
5978 * function - bscv_watchdog_cyclic_add
5979 * description - add the watchdog patter cyclic
5980 * inputs - driver soft state
5981 * outputs - none
5982 */
5983 static void
5985 {
5988 }
5995 }
5997 /*
5998 * function - bscv_watchdog_cyclic_remove
5999 * description - remove the watchdog patter cyclic
6000 * inputs - soft state ptr
6001 * outputs - none
6002 */
6003 static void
6005 {
6008 }
6013 }
6017 /*
6018 * General utility routines ...
6019 */
6021 #ifdef DEBUG
6023 static void
6026 {
6044 }
6045 }
6050 static void
6053 {
6054 }