/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #pragma ident "%Z%%M% %I% %E% SMI" /* * bscv.c - multi-threaded lom driver for the Stiletto platform. */ /* * Included files. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* * Variables defined here and visible internally only */ static void *bscv_statep = NULL; /* * Forward declarations */ static int bscv_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **); static int bscv_attach(dev_info_t *, ddi_attach_cmd_t); static int bscv_detach(dev_info_t *, ddi_detach_cmd_t); static int bscv_reset(dev_info_t *, ddi_reset_cmd_t); static int bscv_map_regs(bscv_soft_state_t *); static void bscv_unmap_regs(bscv_soft_state_t *); static void bscv_map_chan_logical_physical(bscv_soft_state_t *); static int bscv_open(dev_t *, int, int, cred_t *); static int bscv_close(dev_t, int, int, cred_t *); static void bscv_full_stop(bscv_soft_state_t *); static void bscv_enter(bscv_soft_state_t *); static void bscv_exit(bscv_soft_state_t *); #ifdef DEBUG static int bscv_held(bscv_soft_state_t *); #endif /* DEBUG */ static void bscv_put8(bscv_soft_state_t *, int, bscv_addr_t, uint8_t); static void bscv_put16(bscv_soft_state_t *, int, bscv_addr_t, uint16_t); static void bscv_put32(bscv_soft_state_t *, int, bscv_addr_t, uint32_t); static uint8_t bscv_get8(bscv_soft_state_t *, int, bscv_addr_t); static uint16_t bscv_get16(bscv_soft_state_t *, int, bscv_addr_t); static uint32_t bscv_get32(bscv_soft_state_t *, int, bscv_addr_t); static void bscv_setclear8(bscv_soft_state_t *, int, bscv_addr_t, uint8_t, uint8_t); static void bscv_setclear8_volatile(bscv_soft_state_t *, int, bscv_addr_t, uint8_t, uint8_t); static void bscv_rep_rw8(bscv_soft_state_t *, int, uint8_t *, bscv_addr_t, size_t, uint_t, boolean_t); static uint8_t bscv_get8_cached(bscv_soft_state_t *, bscv_addr_t); static uint8_t bscv_get8_locked(bscv_soft_state_t *, int, bscv_addr_t, int *); static void bscv_rep_get8_locked(bscv_soft_state_t *, int, uint8_t *, bscv_addr_t, size_t, uint_t, int *); static boolean_t bscv_faulty(bscv_soft_state_t *); static void bscv_clear_fault(bscv_soft_state_t *); static void bscv_set_fault(bscv_soft_state_t *); static boolean_t bscv_session_error(bscv_soft_state_t *); static int bscv_retcode(bscv_soft_state_t *); static int bscv_should_retry(bscv_soft_state_t *); static void bscv_locked_result(bscv_soft_state_t *, int *); static void bscv_put8_once(bscv_soft_state_t *, int, bscv_addr_t, uint8_t); static uint8_t bscv_get8_once(bscv_soft_state_t *, int, bscv_addr_t); static uint32_t bscv_probe(bscv_soft_state_t *, int, uint32_t *); static void bscv_resync_comms(bscv_soft_state_t *, int); static boolean_t bscv_window_setup(bscv_soft_state_t *); static int bscv_eerw(bscv_soft_state_t *, uint32_t, uint8_t *, unsigned, boolean_t); static int bscv_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); static int bscv_ioc_dogstate(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_psustate(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_fanstate(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_fledstate(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_ledstate(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_info(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_mread(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_volts(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_stats(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_temp(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_cons(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_eventlog2(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_info2(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_test(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_mprog2(bscv_soft_state_t *, intptr_t, int); static int bscv_ioc_mread2(bscv_soft_state_t *, intptr_t, int); static void bscv_event_daemon(void *); static void bscv_start_event_daemon(bscv_soft_state_t *); static int bscv_stop_event_daemon(bscv_soft_state_t *); static int bscv_pause_event_daemon(bscv_soft_state_t *); static void bscv_resume_event_daemon(bscv_soft_state_t *); static void bscv_event_process(bscv_soft_state_t *ssp, boolean_t); static int bscv_event_validate(bscv_soft_state_t *, uint32_t, uint8_t); static void bscv_event_process_one(bscv_soft_state_t *, lom_event_t *); static void bscv_build_eventstring(bscv_soft_state_t *, lom_event_t *, char *, char *); static int bscv_level_of_event(lom_event_t *); static void bscv_status(bscv_soft_state_t *, uint8_t, uint8_t); char *bscv_get_label(char [][MAX_LOM2_NAME_STR], int, int); static void bscv_generic_sysevent(bscv_soft_state_t *, char *, char *, char *, char *, int32_t, char *); static void bscv_sysevent(bscv_soft_state_t *, lom_event_t *); static int bscv_prog(bscv_soft_state_t *, intptr_t, int); static int bscv_prog_image(bscv_soft_state_t *, boolean_t, uint8_t *, int, uint32_t); static int bscv_prog_receive_image(bscv_soft_state_t *, lom_prog_t *, uint8_t *, int); static void bscv_leave_programming_mode(bscv_soft_state_t *, boolean_t); static int bscv_prog_stop_lom(bscv_soft_state_t *); static int bscv_prog_start_lom(bscv_soft_state_t *); static int bscv_attach_common(bscv_soft_state_t *); static int bscv_cleanup(bscv_soft_state_t *); static void bscv_setup_capability(bscv_soft_state_t *); static int bscv_probe_check(bscv_soft_state_t *); static void bscv_setup_hostname(bscv_soft_state_t *); static void bscv_read_hostname(bscv_soft_state_t *, char *); static void bscv_write_hostname(bscv_soft_state_t *, char *, uint8_t); static void bscv_setup_static_info(bscv_soft_state_t *); static uint8_t bscv_read_env_name(bscv_soft_state_t *, uint8_t, uint8_t, uint8_t, char [][MAX_LOM2_NAME_STR], int); static void bscv_setup_events(bscv_soft_state_t *); static void bscv_trace(bscv_soft_state_t *, char, const char *, const char *, ...); #ifdef __sparc static void bscv_idi_init(); static void bscv_idi_fini(); static void bscv_idi_new_instance(dev_info_t *dip); static void bscv_idi_clear_err(); void bscv_idi_set(struct bscv_idi_info info); static boolean_t bscv_idi_err(); static boolean_t bscv_nodename_set(struct bscv_idi_info info); static boolean_t bscv_sig_set(struct bscv_idi_info info); static boolean_t bscv_wdog_pat(struct bscv_idi_info info); static boolean_t bscv_wdog_cfg(struct bscv_idi_info info); static void bscv_write_sig(bscv_soft_state_t *ssp, bscv_sig_t s); #endif /* __sparc */ static void bscv_setup_watchdog(bscv_soft_state_t *ssp); static void bscv_write_wdog_cfg(bscv_soft_state_t *, uint_t, boolean_t, uint8_t); #if defined(__i386) || defined(__amd64) static void bscv_inform_bsc(bscv_soft_state_t *, uint32_t); static void bscv_watchdog_pat_request(void *); static void bscv_watchdog_cfg_request(bscv_soft_state_t *, uint8_t); static uint_t bscv_set_watchdog_timer(bscv_soft_state_t *, uint_t); static void bscv_clear_watchdog_timer(bscv_soft_state_t *); static boolean_t bscv_panic_callback(void *, int); static void bscv_watchdog_cyclic_add(bscv_soft_state_t *); static void bscv_watchdog_cyclic_remove(bscv_soft_state_t *); extern kmutex_t cpu_lock; /* needed for cyclics */ static uint8_t wdog_reset_on_timeout = 1; #define WDOG_ON 1 #define WDOG_OFF 0 #define CLK_WATCHDOG_DEFAULT 10 /* 10 seconds */ #define WATCHDOG_PAT_INTERVAL 1000000000 /* 1 second */ static int bscv_watchdog_enable; static int bscv_watchdog_available; static int watchdog_activated; static uint_t bscv_watchdog_timeout_seconds; #endif /* __i386 || __amd64 */ #ifdef __sparc struct bscv_idi_callout bscv_idi_callout_table[] = { {BSCV_IDI_NODENAME, &bscv_nodename_set }, {BSCV_IDI_SIG, &bscv_sig_set }, {BSCV_IDI_WDOG_PAT, &bscv_wdog_pat }, {BSCV_IDI_WDOG_CFG, &bscv_wdog_cfg }, {BSCV_IDI_NULL, NULL } }; static struct bscv_idi_callout_mgr bscv_idi_mgr; #endif /* __sparc */ /* * Local Definitions */ #define STATUS_READ_LIMIT 8 /* Read up to 8 status changes at a time */ #define MYNAME "bscv" #define BSCV_INST_TO_MINOR(i) (i) #define BSCV_MINOR_TO_INST(m) (m) #define ddi_driver_major(dip) ddi_name_to_major(ddi_binding_name(dip)) /* * Strings for daemon event reporting */ static char *eventSubsysStrings[] = { "", /* 00 */ "Alarm ", /* 01 */ "temperature sensor ", /* 02 */ "overheat sensor ", /* 03 */ "Fan ", /* 04 */ "supply rail ", /* 05 */ "circuit breaker ", /* 06 */ "PSU ", /* 07 */ "user ", /* 08 */ "phonehome ", /* 09; unutilized */ "LOM ", /* 0a */ "host ", /* 0b */ "event log ", /* 0c */ "", /* 0d; EVENT_SUBSYS_EXTRA unutilized */ "LED ", /* 0e */ }; static char *eventTypeStrings[] = { "[null event]", /* 00 */ "ON", /* 01 */ "OFF", /* 02 */ "state change", /* 03 */ "power on", /* 04 */ "power off", /* 05 */ "powered off unexpectedly", /* 06 */ "reset unexpectedly", /* 07 */ "booted", /* 08 */ "watchdog enabled", /* 09 */ "watchdog disabled", /* 0a */ "watchdog triggered", /* 0b */ "failed", /* 0c */ "recovered", /* 0d */ "reset", /* 0e */ "XIR reset", /* 0f */ "console selected", /* 10 */ "time reference", /* 11 */ "script failure", /* 12 */ "modem access failure", /* 13 */ "modem dialing failure", /* 14 */ "bad checksum", /* 15 */ "added", /* 16 */ "removed", /* 17 */ "changed", /* 18 */ "login", /* 19 */ "password changed", /* 1a */ "login failed", /* 1b */ "logout", /* 1c */ "flash download", /* 1d */ "data lost", /* 1e */ "device busy", /* 1f */ "fault led state", /* 20 */ "overheat", /* 21 */ "severe overheat", /* 22 */ "no overheat", /* 23 */ "SCC", /* 24 */ "device inaccessible", /* 25 */ "Hostname change", /* 26 */ "CPU signature timeout", /* 27 */ "Bootmode change", /* 28 */ "Watchdog change policy", /* 29 */ "Watchdog change timeout", /* 2a */ }; /* * These store to mapping between the logical service, e.g. chan_prog for * programming, and the actual Xbus channel which carries that traffic. * Any services can be shared on the same channel apart from chan_wdogpat. */ static int chan_general; /* General Traffic */ static int chan_wdogpat; /* Watchdog Patting */ static int chan_cpusig; /* CPU signatures */ static int chan_eeprom; /* EEPROM I/O */ static int chan_prog; /* Programming */ /* * cb_ops structure defining the driver entry points */ static struct cb_ops bscv_cb_ops = { bscv_open, /* open */ bscv_close, /* close */ nodev, /* strategy */ nodev, /* print */ nodev, /* dump */ nodev, /* read */ nodev, /* write */ bscv_ioctl, /* ioctl */ nodev, /* devmap */ nodev, /* mmap */ nodev, /* segmap */ nochpoll, /* poll */ ddi_prop_op, /* prop op */ NULL, /* ! STREAMS */ D_NEW | D_MP /* MT/MP Safe */ }; /* * dev_ops structure defining autoconfiguration driver autoconfiguration * routines */ static struct dev_ops bscv_dev_ops = { DEVO_REV, /* devo_rev */ 0, /* devo_refcnt */ bscv_getinfo, /* devo_getinfo */ nulldev, /* devo_identify */ nulldev, /* devo_probe */ bscv_attach, /* devo_attach */ bscv_detach, /* devo_detach */ bscv_reset, /* devo_reset */ &bscv_cb_ops, /* devo_cb_ops */ (struct bus_ops *)0 /* devo_bus_ops */ }; /* * module configuration section */ #ifdef DEBUG #define BSCV_VERSION_STRING "bscv driver - Debug v%I%" #else /* DEBUG */ #define BSCV_VERSION_STRING "bscv driver v%I%" #endif /* DEBUG */ static struct modldrv modldrv = { &mod_driverops, BSCV_VERSION_STRING, &bscv_dev_ops, }; static struct modlinkage modlinkage = { MODREV_1, &modldrv, NULL }; /* * kernel accessible routines. These routines are necessarily global so the * driver can be loaded, and unloaded successfully */ /* * function - _init * description - initializes the driver state structure and installs the * driver module into the kernel * inputs - none * outputs - success or failure of module installation */ int _init(void) { register int e; if ((e = ddi_soft_state_init(&bscv_statep, sizeof (bscv_soft_state_t), 1)) != 0) { return (e); } if ((e = mod_install(&modlinkage)) != 0) { ddi_soft_state_fini(&bscv_statep); } #ifdef __sparc if (e == 0) bscv_idi_init(); #endif /* __sparc */ return (e); } /* * function - _info * description - provide information about a kernel loaded module * inputs - module infomation * outputs - success or failure of information request */ int _info(struct modinfo *modinfop) { return (mod_info(&modlinkage, modinfop)); } /* * function - _fini * description - removes a module from the kernel and frees the driver soft * state memory * inputs - none * outputs - success or failure of module removal */ int _fini(void) { register int e; if ((e = mod_remove(&modlinkage)) != 0) { return (e); } #ifdef __sparc bscv_idi_fini(); #endif /* __sparc */ ddi_soft_state_fini(&bscv_statep); return (e); } /* * function - bscv_getinfo * description - routine used to provide information on the driver * inputs - device information structure, command, command arg, storage * area for the result * outputs - DDI_SUCCESS or DDI_FAILURE */ /*ARGSUSED*/ static int bscv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result) { bscv_soft_state_t *ssp; dev_t dev = (dev_t)arg; int instance; int error; instance = DEVICETOINSTANCE(dev); switch (cmd) { case DDI_INFO_DEVT2INSTANCE: *result = (void *)(uintptr_t)instance; error = DDI_SUCCESS; break; case DDI_INFO_DEVT2DEVINFO: ssp = ddi_get_soft_state(bscv_statep, instance); if (ssp == NULL) return (DDI_FAILURE); *result = (void *) ssp->dip; error = DDI_SUCCESS; break; default: error = DDI_FAILURE; break; } return (error); } #ifdef __sparc void bscv_idi_init() { bscv_idi_mgr.valid_inst = (uint32_t)~0; /* No valid instances */ bscv_idi_mgr.tbl = bscv_idi_callout_table; bscv_idi_mgr.errs = 0; /* * Now that all fields are initialized, set the magic flag. This is * a kind of integrity check for the data structure. */ bscv_idi_mgr.magic = BSCV_IDI_CALLOUT_MAGIC; } static void bscv_idi_clear_err() { ASSERT(bscv_idi_mgr.magic == BSCV_IDI_CALLOUT_MAGIC); bscv_idi_mgr.errs = 0; } /* * function - bscv_idi_err * description - error messaging service which throttles the number of error * messages to avoid overflowing storage * inputs - none * returns - boolean to indicate whether a message should be reported * side-effects - updates the error number counter */ static boolean_t bscv_idi_err() { ASSERT(bscv_idi_mgr.magic == BSCV_IDI_CALLOUT_MAGIC); bscv_idi_mgr.errs++; if (bscv_idi_mgr.errs++ < BSCV_IDI_ERR_MSG_THRESHOLD) return (B_TRUE); return (B_FALSE); } void bscv_idi_new_instance(dev_info_t *dip) { ASSERT(bscv_idi_mgr.magic == BSCV_IDI_CALLOUT_MAGIC); /* * We don't care how many instances we have, or their value, so long * as we have at least one valid value. This is so service routines * can get any required locks via a soft state pointer. */ if (bscv_idi_mgr.valid_inst == (uint32_t)~0) { bscv_idi_mgr.valid_inst = ddi_get_instance(dip); } } void bscv_idi_fini() { bscv_idi_mgr.valid_inst = (uint32_t)~0; /* No valid instances */ bscv_idi_mgr.tbl = NULL; } #endif /* __sparc */ /* * function - bscv_attach * description - this routine is responsible for setting aside memory for the * driver data structures, initialising the mutexes and creating * the device minor nodes. Additionally, this routine calls the * the callback routine. * inputs - device information structure, DDI_ATTACH command * outputs - DDI_SUCCESS or DDI_FAILURE */ int bscv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) { bscv_soft_state_t *ssp; int instance; switch (cmd) { case DDI_ATTACH: instance = ddi_get_instance(dip); if (ddi_soft_state_zalloc(bscv_statep, instance) != DDI_SUCCESS) { return (DDI_FAILURE); } ssp = ddi_get_soft_state(bscv_statep, instance); ssp->progress = 0; ssp->dip = dip; ssp->instance = instance; ssp->event_waiting = B_FALSE; ssp->status_change = B_FALSE; ssp->nodename_change = B_FALSE; ssp->cap0 = 0; ssp->cap1 = 0; ssp->cap2 = 0; ssp->prog_mode_only = B_FALSE; ssp->programming = B_FALSE; ssp->cssp_prog = B_FALSE; ssp->task_flags = 0; ssp->debug = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "debug", 0); ssp->majornum = ddi_driver_major(dip); ssp->minornum = BSCV_INST_TO_MINOR(instance); #if defined(__i386) || defined(__amd64) ssp->last_nodename[0] = '\0'; #endif /* __i386 || __amd64 */ /* * initialise the mutexes */ mutex_init(&ssp->cmd_mutex, NULL, MUTEX_DRIVER, NULL); mutex_init(&ssp->task_mu, NULL, MUTEX_DRIVER, NULL); cv_init(&ssp->task_cv, NULL, CV_DRIVER, NULL); cv_init(&ssp->task_evnt_cv, NULL, CV_DRIVER, NULL); mutex_init(&ssp->prog_mu, NULL, MUTEX_DRIVER, NULL); ssp->progress |= BSCV_LOCKS; bscv_trace(ssp, 'A', "bscv_attach", "bscv_attach: mutexes and condition vars initialised"); /* Map in physical communication channels */ if (bscv_map_regs(ssp) != DDI_SUCCESS) { (void) bscv_cleanup(ssp); return (DDI_FAILURE); } ssp->progress |= BSCV_MAPPED_REGS; /* Associate logical channels to physical channels */ bscv_map_chan_logical_physical(ssp); bscv_enter(ssp); bscv_leave_programming_mode(ssp, B_FALSE); if (bscv_attach_common(ssp) == DDI_FAILURE) { bscv_exit(ssp); (void) bscv_cleanup(ssp); return (DDI_FAILURE); } #ifdef __sparc /* * At this point the inter-driver-interface is made available. * The IDI uses the event thread service which * bscv_attach_common() sets up. */ bscv_idi_new_instance(dip); #endif /* __sparc */ bscv_exit(ssp); /* * now create the minor nodes */ if (ddi_create_minor_node(ssp->dip, "lom", S_IFCHR, BSCV_INST_TO_MINOR(instance), DDI_PSEUDO, 0) != DDI_SUCCESS) { (void) bscv_cleanup(ssp); return (DDI_FAILURE); } bscv_trace(ssp, 'A', "bscv_attach", "bscv_attach: device minor nodes created"); ssp->progress |= BSCV_NODES; if (!ssp->prog_mode_only) bscv_start_event_daemon(ssp); #if defined(__i386) || defined(__amd64) bscv_watchdog_enable = 1; bscv_watchdog_available = 1; watchdog_activated = 0; bscv_watchdog_timeout_seconds = CLK_WATCHDOG_DEFAULT; if (bscv_watchdog_enable && (boothowto & RB_DEBUG)) { bscv_watchdog_available = 0; cmn_err(CE_WARN, "bscv: kernel debugger " "detected: hardware watchdog disabled"); } /* * Before we enable the watchdog - register the panic * callback so that we get called to stop the watchdog * in the case of a panic. */ ssp->callb_id = callb_add(bscv_panic_callback, (void *)ssp, CB_CL_PANIC, ""); if (bscv_watchdog_available) { (void) bscv_set_watchdog_timer(ssp, CLK_WATCHDOG_DEFAULT); bscv_enter(ssp); bscv_setup_watchdog(ssp); /* starts cyclic callback */ bscv_exit(ssp); } #endif /* __i386 || __amd64 */ ddi_report_dev(dip); return (DDI_SUCCESS); default: return (DDI_FAILURE); } } /* * function - bscv_detach * description - routine that prepares a module to be unloaded. It undoes all * the work done by the bscv_attach)() routine. This is * facilitated by the use of the progress indicator * inputs - device information structure, DDI_DETACH command * outputs - DDI_SUCCESS or DDI_FAILURE */ /*ARGSUSED*/ static int bscv_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) { return (DDI_FAILURE); } /* * function - bscv_reset * description - routine called when system is being stopped - used to disable * the watchdog. * inputs - device information structure, DDI_RESET command * outputs - DDI_SUCCESS or DDI_FAILURE */ static int bscv_reset(dev_info_t *dip, ddi_reset_cmd_t cmd) { bscv_soft_state_t *ssp; int instance; switch (cmd) { case DDI_RESET_FORCE: instance = ddi_get_instance(dip); ssp = ddi_get_soft_state(bscv_statep, instance); if (ssp == NULL) { return (DDI_FAILURE); } bscv_full_stop(ssp); return (DDI_SUCCESS); default: return (DDI_FAILURE); } } /* * cb_ops routines */ /* * function - bscv_open * description - routine to provide association between user fd and device * minor number. This routine is necessarily simple since a * read/write interface is not provided. Additionally, the * driver does not enforce exclusive access (FEXCL) or * non-blocking during an open (FNDELAY). Deferred attach is * supported. * inputs - device number, flag specifying open type, device type, * permissions * outputs - success or failure of operation */ /*ARGSUSED*/ static int bscv_open(dev_t *devp, int flag, int otype, cred_t *cred) { bscv_soft_state_t *ssp; int instance; instance = DEVICETOINSTANCE(*devp); ssp = ddi_get_soft_state(bscv_statep, instance); if (ssp == NULL) { return (ENXIO); /* not attached yet */ } bscv_trace(ssp, 'O', "bscv_open", "instance 0x%x", instance); if (otype != OTYP_CHR) { return (EINVAL); } return (0); } /* * function - bscv_close * description - routine to perform the final close on the device. As per the * open routine, neither FEXCL or FNDELAY accesses are enforced * by the driver. * inputs - device number,flag specifying open type, device type, * permissions * outputs - success or failure of operation */ /*ARGSUSED1*/ static int bscv_close(dev_t dev, int flag, int otype, cred_t *cred) { bscv_soft_state_t *ssp; int instance; instance = DEVICETOINSTANCE(dev); ssp = ddi_get_soft_state(bscv_statep, instance); if (ssp == NULL) { return (ENXIO); } bscv_trace(ssp, 'O', "bscv_close", "instance 0x%x", instance); return (0); } static int bscv_map_regs(bscv_soft_state_t *ssp) { int i; int retval; int *props; unsigned int nelements; ASSERT(ssp); ssp->nchannels = 0; /* * Work out how many channels are available by looking at the number * of elements of the regs property array. */ retval = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, ssp->dip, DDI_PROP_DONTPASS, "reg", &props, &nelements); /* We don't need props anymore. Free memory if it was allocated */ if (retval == DDI_PROP_SUCCESS) ddi_prop_free(props); /* Check for sanity of nelements */ if (retval != DDI_PROP_SUCCESS) { bscv_trace(ssp, 'A', "bscv_map_regs", "lookup reg returned" " 0x%x", retval); goto cleanup_exit; } else if (nelements % LOMBUS_REGSPEC_SIZE != 0) { bscv_trace(ssp, 'A', "bscv_map_regs", "nelements %d not" " a multiple of %d", nelements, LOMBUS_REGSPEC_SIZE); goto cleanup_exit; } else if (nelements > BSCV_MAXCHANNELS * LOMBUS_REGSPEC_SIZE) { bscv_trace(ssp, 'A', "bscv_map_regs", "nelements %d too large" ", probably a misconfiguration", nelements); goto cleanup_exit; } else if (nelements < BSCV_MINCHANNELS * LOMBUS_REGSPEC_SIZE) { bscv_trace(ssp, 'A', "bscv_map_regs", "nelements %d too small" ", need to have at least a general and a wdog channel", nelements); goto cleanup_exit; } ssp->nchannels = nelements / LOMBUS_REGSPEC_SIZE; ssp->attr.devacc_attr_version = DDI_DEVICE_ATTR_V0; ssp->attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC; ssp->attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC; for (i = 0; i < ssp->nchannels; i++) { retval = ddi_regs_map_setup(ssp->dip, i, (caddr_t *)&ssp->channel[i].regs, 0, 0, &ssp->attr, &ssp->channel[i].handle); if (retval != DDI_SUCCESS) { bscv_trace(ssp, 'A', "bscv_map_regs", "map failure" " 0x%x on space %d", retval, i); /* Rewind all current mappings - avoiding failed one */ i--; for (; i >= 0; i--) { ddi_regs_map_free(&ssp->channel[i].handle); } goto cleanup_exit; } } return (DDI_SUCCESS); cleanup_exit: /* * It is important to set nchannels to 0 even if, say, only one of * the two required handles was mapped. If we cannot achieve our * minimum config its not safe to do any IO; this keeps our failure * mode handling simpler. */ ssp->nchannels = 0; return (DDI_FAILURE); } static void bscv_unmap_regs(bscv_soft_state_t *ssp) { int i; ASSERT(ssp); for (i = 0; i < ssp->nchannels; i++) { ddi_regs_map_free(&ssp->channel[i].handle); } } /* * Map logical services onto physical XBus channels. */ static void bscv_map_chan_logical_physical(bscv_soft_state_t *ssp) { ASSERT(ssp); /* * We can assert that there will always be at least two channels, * to allow watchdog pats to be segregated from all other traffic. */ chan_general = 0; chan_wdogpat = 1; /* * By default move all other services onto the generic channel unless * the hardware supports additional channels. */ chan_cpusig = chan_eeprom = chan_prog = chan_general; if (ssp->nchannels > 2) chan_cpusig = 2; if (ssp->nchannels > 3) chan_eeprom = 3; if (ssp->nchannels > 4) chan_prog = 4; } /* * function - bscv_full_stop * description - gracefully shut the lom down during panic or reboot. * Disables the watchdog, setup up serial event reporting * and stops the event daemon running. * inputs - soft state pointer * outputs - none */ void bscv_full_stop(bscv_soft_state_t *ssp) { uint8_t bits2set = 0; uint8_t bits2clear = 0; bscv_trace(ssp, 'W', "bscv_full_stop", "turning off watchdog"); if (!ddi_in_panic()) { /* Stop the event daemon if we are not panicking. */ (void) bscv_pause_event_daemon(ssp); } bscv_enter(ssp); #if defined(__i386) || defined(__amd64) if (ddi_in_panic()) { bscv_inform_bsc(ssp, BSC_INFORM_PANIC); } else { bscv_inform_bsc(ssp, BSC_INFORM_OFFLINE); } #endif /* __i386 || __amd64 */ /* set serial event reporting */ switch (ssp->serial_reporting) { case LOM_SER_EVENTS_ON: case LOM_SER_EVENTS_DEF: /* Make sure serial event reporting is on */ bits2clear = EBUS_ALARM_NOEVENTS; break; case LOM_SER_EVENTS_OFF: /* Make sure serial event reporting is on */ bits2set = EBUS_ALARM_NOEVENTS; break; default: break; } bscv_setclear8_volatile(ssp, chan_general, EBUS_IDX_ALARM, bits2set, bits2clear); bscv_exit(ssp); } /* * LOM I/O routines. * * locking * * Two sets of routines are provided: * normal - must be called after acquiring an appropriate lock. * locked - perform all the locking required and return any error * code in the supplied 'res' argument. If there is no * error 'res' is not changed. * The locked routines are designed for use in ioctl commands where * only a single operation needs to be performed and the overhead of * locking and result checking adds significantly to code complexity. * * locking primitives * * bscv_enter() - acquires an I/O lock for the calling thread. * bscv_exit() - releases an I/O lock acquired by bscv_enter(). * bscv_held() - used to assert ownership of an I/O lock. * * normal I/O routines * * Note bscv_{put|get}{16|32} routines are big-endian. This assumes that * the firmware works that way too. * * bscv_put8(), bscv_put16, bscv_put32 - write values to the LOM * and handle any retries if necessary. * 16 and 32 bit values are big-endian. * bscv_get8(), bscv_get16, bscv_get32 - read values from the LOM * and handle any retries if necessary. * 16 and 32 bit values are big-endian. * bscv_setclear8() - set or clear the specified bits in the register * at the supplied address. * bscv_setclear8_volatile() - set or clear the specified bits in the * register at the supplied address. If the lom reports * that the registers has changed since the last read * re-read and apply the set or clear to the new bits. * bscv_get8_cached() - Return a cached register value (addr < 0x80). * Does not access the hardware. A read of the hardware * automatically updates this cache. * * locked I/O routines * * bscv_get8_locked(), bscv_rep_get8_locked(). * * Call the indicated function from above, but wrapping it with * bscv_enter()/bscv_exit(). * * * Fault management * * LOM communications fault are grouped into three categories: * 1) Faulty - the LOM is not responding and no attempt to communicate * with it should be made. * 2) Transient fault - something which might recover after a retry * but which doesn't affect our ability to perform other * commands. * 3) Command error - an inappropriate command was executed. A retry * will not fix it but the command failed. * * The current implementation of the bscv driver is not very good at * noticing command errors due to the structure of the original code * that it is based on. It is possible to extend the driver to do this * and would probably involve having a concept of a "session error" * which is less severe than a fault but means that a sequence of * commands had some fault which cannot be recovered. * * * faults * * bscv_faulty() - returns B_TRUE if the LOM (communications) have been * declared faulty. * bscv_clear_fault() - marks the LOM as not faulty. * bscv_set_fault() - marks the LOM as being faulty. * * bscv_clear_fault and bscv_set_fault should generally not be called * directly. * * command errors/transient faults * * bscv_retcode() - returns the actual error code of the last operation. * bscv_should_retry() - determines if last operation may suceed if * retried. * bscv_locked_result() - Set the result of a locked register access. * * low level I/O primitives * * These are generally not called directly. These perform a single * access to the LOM device. They do not handle retries. * * bscv_put8_once() * bscv_get8_once() * bscv_probe() - perform a probe (NOP) operation to check out lom comms. * bscv_resync_comms() - resynchronise communications after a transient fault. */ static void bscv_enter(bscv_soft_state_t *ssp) { bscv_trace(ssp, '@', "bscv_enter", ""); mutex_enter(&ssp->cmd_mutex); ssp->had_session_error = B_FALSE; } static void bscv_exit(bscv_soft_state_t *ssp) { mutex_exit(&ssp->cmd_mutex); bscv_trace(ssp, '@', "bscv_exit", ""); } #ifdef DEBUG static int bscv_held(bscv_soft_state_t *ssp) { return (mutex_owned(&ssp->cmd_mutex)); } #endif /* DEBUG */ static void bscv_put8(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, uint8_t val) { boolean_t needretry; int num_failures; ASSERT(bscv_held(ssp)); if (bscv_faulty(ssp)) { return; } bscv_trace(ssp, '@', "bscv_put8", "addr 0x%x.%02x <= 0x%02x", addr >> 8, addr & 0xff, val); for (num_failures = 0; num_failures < BSC_FAILURE_RETRY_LIMIT; num_failures++) { bscv_put8_once(ssp, chan, addr, val); needretry = bscv_should_retry(ssp); if (!needretry) { break; } } if (ssp->command_error != 0) { ssp->had_session_error = B_TRUE; } if (needretry) { /* Failure - we ran out of retries */ cmn_err(CE_WARN, "bscv_put8: addr 0x%x.%02x retried " "write %d times, giving up", addr >> 8, addr & 0xff, num_failures); bscv_set_fault(ssp); } else if (num_failures > 0) { bscv_trace(ssp, 'R', "bscv_put8", "addr 0x%x.%02x retried write %d times, succeeded", addr >> 8, addr & 0xff, num_failures); } } static void bscv_put16(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, uint16_t val) { ASSERT(bscv_held(ssp)); bscv_trace(ssp, '@', "bscv_put16", "addr 0x%x.%02x <= %04x", addr >> 8, addr & 0xff, val); bscv_put8(ssp, chan, addr, val >> 8); bscv_put8(ssp, chan, addr + 1, val & 0xff); } static void bscv_put32(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, uint32_t val) { ASSERT(bscv_held(ssp)); bscv_trace(ssp, '@', "bscv_put32", "addr 0x%x.%02x <= %08x", addr >> 8, addr & 0xff, val); bscv_put8(ssp, chan, addr, (val >> 24) & 0xff); bscv_put8(ssp, chan, addr + 1, (val >> 16) & 0xff); bscv_put8(ssp, chan, addr + 2, (val >> 8) & 0xff); bscv_put8(ssp, chan, addr + 3, val & 0xff); } static uint8_t bscv_get8(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr) { uint8_t retval; boolean_t needretry; int num_failures; ASSERT(bscv_held(ssp)); if (bscv_faulty(ssp)) { return (0); } for (num_failures = 0; num_failures < BSC_FAILURE_RETRY_LIMIT; num_failures++) { retval = bscv_get8_once(ssp, chan, addr); needretry = bscv_should_retry(ssp); if (!needretry) { break; } } if (ssp->command_error != 0) { ssp->had_session_error = B_TRUE; } if (needretry) { /* Failure */ cmn_err(CE_WARN, "bscv_get8: addr 0x%x.%02x retried " "read %d times, giving up", addr >> 8, addr & 0xff, num_failures); bscv_set_fault(ssp); } else if (num_failures > 0) { bscv_trace(ssp, 'R', "bscv_get8", "addr 0x%x.%02x retried read %d times, succeeded", addr >> 8, addr & 0xff, num_failures); } bscv_trace(ssp, '@', "bscv_get8", "addr 0x%x.%02x => %02x", addr >> 8, addr & 0xff, retval); return (retval); } static uint16_t bscv_get16(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr) { uint16_t retval; ASSERT(bscv_held(ssp)); retval = bscv_get8(ssp, chan, addr) << 8; retval |= bscv_get8(ssp, chan, addr + 1); bscv_trace(ssp, '@', "bscv_get16", "addr 0x%x.%02x => %04x", addr >> 8, addr & 0xff, retval); return (retval); } static uint32_t bscv_get32(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr) { uint32_t retval; ASSERT(bscv_held(ssp)); retval = bscv_get8(ssp, chan, addr) << 24; retval |= bscv_get8(ssp, chan, addr + 1) << 16; retval |= bscv_get8(ssp, chan, addr + 2) << 8; retval |= bscv_get8(ssp, chan, addr + 3); bscv_trace(ssp, '@', "bscv_get32", "addr 0x%x.%02x => %08x", addr >> 8, addr & 0xff, retval); return (retval); } static void bscv_setclear8(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, uint8_t set, uint8_t clear) { uint8_t val; ASSERT(bscv_held(ssp)); ASSERT(addr < BSC_ADDR_CACHE_LIMIT); val = ssp->lom_regs[addr] | set; val &= ~clear; bscv_trace(ssp, '@', "bscv_setclear8", "addr 0x%x.%02x, set %02x, clear %02x => %02x", addr >> 8, addr & 0xff, set, clear, val); bscv_put8(ssp, chan, addr, val); } static void bscv_setclear8_volatile(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, uint8_t set, uint8_t clear) { uint8_t val; boolean_t needretry; int num_failures; ASSERT(bscv_held(ssp)); ASSERT(addr < BSC_ADDR_CACHE_LIMIT); if (bscv_faulty(ssp)) { return; } bscv_trace(ssp, '@', "bscv_setclear8_volatile", "addr 0x%x.%02x => set %02x clear %02x", addr >> 8, addr & 0xff, set, clear); val = bscv_get8_cached(ssp, addr); for (num_failures = 0; num_failures < BSC_FAILURE_RETRY_LIMIT; num_failures++) { val |= set; val &= ~clear; bscv_put8_once(ssp, chan, addr, val); if (ssp->command_error == EBUS_ERROR_STALEDATA) { /* Re-read the stale register from the lom */ val = bscv_get8_once(ssp, chan, addr); needretry = 1; } else { needretry = bscv_should_retry(ssp); if (!needretry) { break; } } } if (ssp->command_error != 0) { ssp->had_session_error = B_TRUE; } if (needretry) { /* Failure */ cmn_err(CE_WARN, "bscv_setclear8_volatile: addr 0x%x.%02x " "retried write %d times, giving up", addr >> 8, addr & 0xff, num_failures); if (ssp->command_error != EBUS_ERROR_STALEDATA) { bscv_set_fault(ssp); } } else if (num_failures > 0) { bscv_trace(ssp, 'R', "bscv_setclear8_volatile", "addr 0x%x.%02x retried write %d times, succeeded", addr >> 8, addr & 0xff, num_failures); } } static void bscv_rep_rw8(bscv_soft_state_t *ssp, int chan, uint8_t *host_addr, bscv_addr_t dev_addr, size_t repcount, uint_t flags, boolean_t is_write) { size_t inc; ASSERT(bscv_held(ssp)); inc = (flags & DDI_DEV_AUTOINCR) ? 1 : 0; for (; repcount--; dev_addr += inc) { if (flags & DDI_DEV_AUTOINCR) { if (is_write) { bscv_put8(ssp, chan, dev_addr, *host_addr++); } else { *host_addr++ = bscv_get8(ssp, chan, dev_addr); } } else { if (is_write) { bscv_put8_once(ssp, chan, dev_addr, *host_addr++); } else { *host_addr++ = bscv_get8_once(ssp, chan, dev_addr); } /* We need this because _once routines don't do it */ if (ssp->command_error != 0) { ssp->had_session_error = B_TRUE; } } if (bscv_faulty(ssp) || bscv_session_error(ssp)) { /* * No retry here. If we were AUTOINCR then get/put * will have retried. For NO_AUTOINCR we cannot retry * because the data would be corrupted. */ break; } } } static uint8_t bscv_get8_cached(bscv_soft_state_t *ssp, bscv_addr_t addr) { ASSERT(addr < BSC_ADDR_CACHE_LIMIT); /* Can be called with or without the lock held */ return (ssp->lom_regs[addr]); } static uint8_t bscv_get8_locked(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, int *res) { uint8_t retval; ASSERT(addr < BSC_ADDR_CACHE_LIMIT); bscv_enter(ssp); retval = bscv_get8(ssp, chan, addr); bscv_locked_result(ssp, res); bscv_exit(ssp); bscv_trace(ssp, '@', "bscv_get8_locked", "addr 0x%x.%02x => %02x", addr >> 8, addr & 0xff, retval); return (retval); } static void bscv_rep_get8_locked(bscv_soft_state_t *ssp, int chan, uint8_t *host_addr, bscv_addr_t dev_addr, size_t repcount, uint_t flags, int *res) { bscv_enter(ssp); bscv_rep_rw8(ssp, chan, host_addr, dev_addr, repcount, flags, B_FALSE /* read */); bscv_locked_result(ssp, res); bscv_exit(ssp); } static boolean_t bscv_faulty(bscv_soft_state_t *ssp) { ASSERT(bscv_held(ssp)); return (ssp->had_fault); } static void bscv_clear_fault(bscv_soft_state_t *ssp) { ASSERT(bscv_held(ssp)); bscv_trace(ssp, 'J', "bscv_clear_fault", "clearing fault flag"); ssp->had_fault = B_FALSE; ssp->had_session_error = B_FALSE; } static void bscv_set_fault(bscv_soft_state_t *ssp) { ASSERT(bscv_held(ssp)); bscv_trace(ssp, 'J', "bscv_set_fault", "setting fault flag"); ssp->had_fault = B_TRUE; } static boolean_t bscv_session_error(bscv_soft_state_t *ssp) { ASSERT(bscv_held(ssp)); return (ssp->had_session_error); } static int bscv_retcode(bscv_soft_state_t *ssp) { bscv_trace(ssp, '@', "bscv_retcode", "code 0x%x", ssp->command_error); return (ssp->command_error); } static int bscv_should_retry(bscv_soft_state_t *ssp) { if ((ssp->command_error == EBUS_ERROR_DEVICEFAIL) || (ssp->command_error >= LOMBUS_ERR_BASE)) { /* This command is due to an I/O fault - retry might fix */ return (1); } else { /* * The command itself was bad - there is no point in fixing * Note. Whatever happens we should know that if we were * doing EBUS_IDX_SELFTEST0..EBUS_IDX_SELFTEST7 and we * had 0x80 set then this is a test error not a retry * error. */ return (0); } } static void bscv_locked_result(bscv_soft_state_t *ssp, int *res) { if (bscv_faulty(ssp) || (bscv_retcode(ssp) != 0)) { *res = EIO; } } static void bscv_put8_once(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, uint8_t val) { uint32_t fault; ASSERT(bscv_held(ssp)); ssp->command_error = 0; if (bscv_faulty(ssp)) { /* Bail out things are not working */ return; } else if (ssp->nchannels == 0) { /* Didn't manage to map handles so ddi_{get,put}* broken */ bscv_trace(ssp, '@', "bscv_put8_once", "nchannels is 0x0 so cannot do IO"); return; } /* Clear any pending fault */ ddi_put32(ssp->channel[chan].handle, (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG), 0); /* Do the access and get fault code - may take a long time */ ddi_put8(ssp->channel[chan].handle, &ssp->channel[chan].regs[addr], val); fault = ddi_get32(ssp->channel[chan].handle, (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG)); ssp->command_error = fault; if (fault == 0) { /* Things were ok - update cache entry */ if (addr < BSC_ADDR_CACHE_LIMIT) { /* Store cacheable entries */ ssp->lom_regs[addr] = val; } } else if (fault >= LOMBUS_ERR_BASE) { /* lombus problem - do a resync session */ cmn_err(CE_WARN, "!bscv_put8_once: Had comms fault " "for address 0x%x.%02x - data 0x%x, fault 0x%x", addr >> 8, addr & 0xff, val, fault); /* Attempt to resync with the lom */ bscv_resync_comms(ssp, chan); /* * Note: we do not set fault status here. That * is done if our caller decides to give up talking to * the lom. The observant might notice that this means * that if we mend things on the last attempt we still * get the fault set - we just live with that! */ } bscv_trace(ssp, '@', "bscv_put8_once", "addr 0x%x.%02x <= 0x%02x", addr >> 8, addr & 0xff, val); } static uint8_t bscv_get8_once(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr) { uint8_t val; uint32_t fault; ASSERT(bscv_held(ssp)); ssp->command_error = 0; if (bscv_faulty(ssp)) { /* Bail out things are not working */ return (0xff); } else if (ssp->nchannels == 0) { /* Didn't manage to map handles so ddi_{get,put}* broken */ bscv_trace(ssp, '@', "bscv_get8_once", "nchannels is 0x0 so cannot do IO"); return (0xff); } /* Clear any pending fault */ ddi_put32(ssp->channel[chan].handle, (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG), 0); /* Do the access and get fault code - may take a long time */ val = ddi_get8(ssp->channel[chan].handle, &ssp->channel[chan].regs[addr]); fault = ddi_get32(ssp->channel[chan].handle, (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG)); ssp->command_error = fault; if (fault >= LOMBUS_ERR_BASE) { /* lombus problem - do a resync session */ cmn_err(CE_WARN, "!bscv_get8_once: Had comms fault " "for address 0x%x.%02x - data 0x%x, fault 0x%x", addr >> 8, addr & 0xff, val, fault); /* Attempt to resync with the lom */ bscv_resync_comms(ssp, chan); /* * Note: we do not set fault status here. That * is done if our caller decides to give up talking to * the lom. The observant might notice that this means * that if we mend things on the last attempt we still * get the fault set - we just live with that! */ } /* * FIXME - should report error if you get * EBUS_ERROR_DEVICEFAIL reported from the BSC. That gets * logged as a failure in bscv_should_retry and may contribute * to a permanent failure. Reference issues seen by Mitac. */ if (!bscv_faulty(ssp)) { if (addr < BSC_ADDR_CACHE_LIMIT) { /* Store cacheable entries */ ssp->lom_regs[addr] = val; } } bscv_trace(ssp, '@', "bscv_get8_once", "addr 0x%x.%02x => 0x%02x", addr >> 8, addr & 0xff, val); return (val); } static uint32_t bscv_probe(bscv_soft_state_t *ssp, int chan, uint32_t *fault) { uint32_t async_reg; if (ssp->nchannels == 0) { /* * Failed to map handles, so cannot do any IO. Set the * fault indicator and return a dummy value. */ bscv_trace(ssp, '@', "bscv_probe", "nchannels is 0x0 so cannot do any IO"); *fault = LOMBUS_ERR_REG_NUM; return ((~(int8_t)0)); } /* Clear faults */ ddi_put32(ssp->channel[chan].handle, (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG), 0); /* Probe and Check faults */ *fault = ddi_get32(ssp->channel[chan].handle, (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_PROBE_REG)); /* Read status */ async_reg = ddi_get32(ssp->channel[chan].handle, (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_ASYNC_REG)); bscv_trace(ssp, '@', "bscv_probe", "async status 0x%x, fault 0x%x", async_reg, *fault); return (async_reg); } static void bscv_resync_comms(bscv_soft_state_t *ssp, int chan) { int try; uint32_t command_error = ssp->command_error; uint32_t fault = 0; if (ssp->nchannels == 0) { /* * Didn't manage to map handles so ddi_{get,put}* broken. * Therefore, there is no way to resync comms. */ bscv_trace(ssp, '@', "bscv_resync_comms", "nchannels is 0x0 so not possible to resync comms"); return; } if (command_error >= LOMBUS_ERR_BASE && command_error != LOMBUS_ERR_REG_NUM && command_error != LOMBUS_ERR_REG_SIZE && command_error != LOMBUS_ERR_TIMEOUT) { /* Resync here to make sure that the lom is talking */ cmn_err(CE_WARN, "!bscv_resync_comms: " "Attempting comms resync after comms fault 0x%x", command_error); for (try = 1; try <= 8; try++) { /* Probe */ fault = ddi_get32(ssp->channel[chan].handle, (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_PROBE_REG)); if (fault == 0) { break; } else { cmn_err(CE_WARN, "!bscv_resync_comms: " "comms resync (probing) - try 0x%x " "had fault 0x%x", try, fault); } } if (fault != 0) { cmn_err(CE_WARN, "!bscv_resync_comms: " "Failed to resync comms - giving up"); ssp->bad_resync++; } else { cmn_err(CE_WARN, "!bscv_resync_comms: " "resync comms after 0x%x tries", try); ssp->bad_resync = 0; } } } /* * LOMLite configuration/event eeprom access routines * * bscv_window_setup() - Read/Sanity check the eeprom parameters. * This must be called prior to calling bscv_eerw(). * bscv_eerw() - Read/write data from/to the eeprom. */ /* * function - bscv_window_setup * description - this routine reads the eeprom parameters and sanity * checks them to ensure that the lom is talking sense. * inputs - soft state ptr * outputs - B_TRUE if the eeprom is ok, B_FALSE if the eeprom is not OK. */ static boolean_t bscv_window_setup(bscv_soft_state_t *ssp) { ASSERT(bscv_held(ssp)); if (ssp->eeinfo_valid) { /* Already have good cached values */ return (ssp->eeinfo_valid); } ssp->eeprom_size = bscv_get8(ssp, chan_general, EBUS_IDX_EEPROM_SIZE_KB) * 1024; ssp->eventlog_start = bscv_get16(ssp, chan_general, EBUS_IDX_LOG_START_HI); /* * The log does not run to the end of the EEPROM because it is a * logical partition. The last 8K partition is reserved for FRUID * usage. */ ssp->eventlog_size = EBUS_LOG_END - ssp->eventlog_start; bscv_trace(ssp, 'I', "bscv_window_setup", "eeprom size 0x%x log_start" " 0x%x log_size 0x%x", ssp->eeprom_size, ssp->eventlog_start, ssp->eventlog_size); if (bscv_faulty(ssp) || bscv_session_error(ssp)) { ssp->eeinfo_valid = B_FALSE; } else if ((ssp->eeprom_size == 0) || (ssp->eventlog_start >= ssp->eeprom_size)) { /* Sanity check values */ cmn_err(CE_WARN, "!bscv_window_setup: read invalid eeprom parameters"); ssp->eeinfo_valid = B_FALSE; } else { ssp->eeinfo_valid = B_TRUE; } bscv_trace(ssp, 'I', "bscv_window_setup", "returning eeinfo_valid %s", ssp->eeinfo_valid ? "true" : "false"); return (ssp->eeinfo_valid); } /* * function - bscv_eerw * description - this routine reads/write data from/to the eeprom. * It takes care of setting the window on the eeprom correctly. * inputs - soft state ptr, eeprom offset, data buffer, size, read/write * outputs - B_TRUE if the eeprom is ok, B_FALSE if the eeprom is not OK. */ static int bscv_eerw(bscv_soft_state_t *ssp, uint32_t eeoffset, uint8_t *buf, unsigned size, boolean_t is_write) { uint32_t blk_addr = eeoffset; unsigned remaining = size; uint8_t page_idx; uint8_t this_page; uint8_t blk_size; int res = 0; while (remaining > 0) { page_idx = blk_addr & 0xff; if ((page_idx + remaining) > 0x100) { blk_size = 0x100 - page_idx; } else { blk_size = remaining; } /* Select correct eeprom page */ this_page = blk_addr >> 8; bscv_put8(ssp, chan_eeprom, EBUS_IDX_EEPROM_PAGESEL, this_page); bscv_trace(ssp, 'M', "lom_eerw", "%s data @0x%x.%02x, size 0x%x, 0x%x bytes remaining", is_write ? "writing" : "reading", this_page, page_idx, blk_size, remaining - blk_size); bscv_rep_rw8(ssp, chan_eeprom, buf, BSCVA(EBUS_CMD_SPACE_EEPROM, page_idx), blk_size, DDI_DEV_AUTOINCR, is_write); if (bscv_faulty(ssp) || bscv_session_error(ssp)) { res = EIO; break; } remaining -= blk_size; blk_addr += blk_size; buf += blk_size; } return (res); } static boolean_t bscv_is_null_event(bscv_soft_state_t *ssp, lom_event_t *e) { ASSERT(e != NULL); if (EVENT_DECODE_SUBSYS(e->ev_subsys) == EVENT_SUBSYS_NONE && e->ev_event == EVENT_NONE) { /* * This marks a NULL event. */ bscv_trace(ssp, 'E', "bscv_is_null_event", "EVENT_SUBSYS_NONE/EVENT_NONE null event"); return (B_TRUE); } else if (e->ev_subsys == 0xff && e->ev_event == 0xff) { /* * Under some circumstances, we've seen all 1s to represent * a manually cleared event log at the BSC prompt. Only * a test/diagnosis environment is likely to show this. */ bscv_trace(ssp, 'E', "bscv_is_null_event", "0xffff null event"); return (B_TRUE); } else { /* * Not a NULL event. */ bscv_trace(ssp, 'E', "bscv_is_null_event", "returning False"); return (B_FALSE); } } /* * ********************************************************************* * IOCTL Processing * ********************************************************************* */ /* * function - bscv_ioctl * description - routine that acts as a high level manager for ioctls. It * calls the appropriate handler for ioctls on the alarm:mon and * alarm:ctl minor nodes respectively * * Unsupported ioctls (now deprecated) * LOMIOCALCTL * LOMIOCALSTATE * LOMIOCCLEARLOG * LOMIOCCTL * LOMIOCCTL2 * LOMIOCDAEMON * LOMIOCDMON * LOMIOCDOGCTL, TSIOCDOGCTL * LOMIOCDOGPAT, TSIOCDOGPAT * LOMIOCDOGTIME, TSIOCDOGTIME * LOMIOCEVENTLOG * LOMIOCEVNT * LOMIOCGETMASK * LOMIOCMPROG * LOMIOCNBMON, TSIOCNBMON * LOMIOCSLEEP * LOMIOCUNLOCK, TSIOCUNLOCK * LOMIOCWTMON, TSIOCWTMON * * Supported ioctls * LOMIOCDOGSTATE, TSIOCDOGSTATE * LOMIOCPROG * LOMIOCPSUSTATE * LOMIOCFANSTATE * LOMIOCFLEDSTATE * LOMIOCINFO * LOMIOCMREAD * LOMIOCVOLTS * LOMIOCSTATS * LOMIOCTEMP * LOMIOCCONS * LOMIOCEVENTLOG2 * LOMIOCINFO2 * LOMIOCTEST * LOMIOCMPROG2 * LOMIOCMREAD2 * * inputs - device number, command, user space arg, filemode, user * credentials, return value * outputs - the return value propagated back by the lower level routines. */ /*ARGSUSED*/ static int bscv_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cred, int *rvalp) { bscv_soft_state_t *ssp; int instance; int res = 0; instance = DEVICETOINSTANCE(dev); ssp = ddi_get_soft_state(bscv_statep, instance); if (ssp == NULL) { return (ENXIO); } /* * The Combined Switch and Service Processor takes care of configuration * and control. The CSSP tells the BSC chip about it; therefore the * bscv driver doesn't send such configuration and control to the BSC. * Additionally Watchdog configuration is no longer done from userland * lom. */ switch (cmd) { case LOMIOCALCTL: case LOMIOCALSTATE: case LOMIOCCLEARLOG: case LOMIOCCTL: case LOMIOCCTL2: case LOMIOCDAEMON: case LOMIOCDMON: case LOMIOCDOGCTL: case LOMIOCDOGPAT: case LOMIOCDOGTIME: case LOMIOCEVENTLOG: case LOMIOCEVNT: case LOMIOCGETMASK: case LOMIOCMPROG: case LOMIOCNBMON: case LOMIOCSLEEP: case LOMIOCUNLOCK: case LOMIOCWTMON: return (ENOTSUP); } /* * set the default result. */ *rvalp = 0; if (ssp->cssp_prog) { return (ENXIO); } else if ((ssp->prog_mode_only || ssp->programming) && cmd != LOMIOCPROG) { return (ENXIO); } /* * Check that the caller has appropriate access permissions * (FWRITE set in mode) for those ioctls which change lom * state */ if (!(mode & FWRITE)) { switch (cmd) { case LOMIOCMPROG2: case LOMIOCMREAD2: case LOMIOCPROG: case LOMIOCTEST: return (EACCES); /* NOTREACHED */ default: /* Does not require write access */ break; } } switch (cmd) { case LOMIOCDOGSTATE: res = bscv_ioc_dogstate(ssp, arg, mode); break; case LOMIOCPROG: res = bscv_prog(ssp, arg, mode); break; case LOMIOCPSUSTATE: res = bscv_ioc_psustate(ssp, arg, mode); break; case LOMIOCFANSTATE: res = bscv_ioc_fanstate(ssp, arg, mode); break; case LOMIOCFLEDSTATE: res = bscv_ioc_fledstate(ssp, arg, mode); break; case LOMIOCLEDSTATE: res = bscv_ioc_ledstate(ssp, arg, mode); break; case LOMIOCINFO: res = bscv_ioc_info(ssp, arg, mode); break; case LOMIOCMREAD: res = bscv_ioc_mread(ssp, arg, mode); break; case LOMIOCVOLTS: res = bscv_ioc_volts(ssp, arg, mode); break; case LOMIOCSTATS: res = bscv_ioc_stats(ssp, arg, mode); break; case LOMIOCTEMP: res = bscv_ioc_temp(ssp, arg, mode); break; case LOMIOCCONS: res = bscv_ioc_cons(ssp, arg, mode); break; case LOMIOCEVENTLOG2: res = bscv_ioc_eventlog2(ssp, arg, mode); break; case LOMIOCINFO2: res = bscv_ioc_info2(ssp, arg, mode); break; case LOMIOCTEST: res = bscv_ioc_test(ssp, arg, mode); break; case LOMIOCMPROG2: res = bscv_ioc_mprog2(ssp, arg, mode); break; case LOMIOCMREAD2: res = bscv_ioc_mread2(ssp, arg, mode); break; default: bscv_trace(ssp, 'I', "bscv_ioctl", "Invalid IOCTL 0x%x", cmd); res = EINVAL; } return (res); } /* * LOMIOCDOGSTATE * TSIOCDOGSTATE - indicate whether the alarm watchdog and reset * circuitry is enabled or not. */ static int bscv_ioc_dogstate(bscv_soft_state_t *ssp, intptr_t arg, int mode) { lom_dogstate_t dogstate; uint8_t dogval; int res = 0; dogval = bscv_get8_locked(ssp, chan_general, EBUS_IDX_WDOG_CTRL, &res); dogstate.dog_enable = (dogval & EBUS_WDOG_ENABLE) ? 1 : 0; dogstate.reset_enable = (dogval & EBUS_WDOG_RST) ? 1 : 0; dogstate.dog_timeout = bscv_get8_locked(ssp, chan_general, EBUS_IDX_WDOG_TIME, &res); if ((res == 0) && (ddi_copyout((caddr_t)&dogstate, (caddr_t)arg, sizeof (dogstate), mode) < 0)) { res = EFAULT; } return (res); } /* * LOMIOCPSUSTATE - returns full information for 4 PSUs. All this * information is available from two bytes of LOMlite RAM, but if * on the first read it is noticed that two or more of the PSUs are * not present only 1 byte will be read subsequently. */ static int bscv_ioc_psustate(bscv_soft_state_t *ssp, intptr_t arg, int mode) { lom_psudata_t psudata; uint8_t psustat; int i; int res = 0; for (i = 0; i < MAX_PSUS; i++) { psustat = bscv_get8_locked(ssp, chan_general, EBUS_IDX_PSU1_STAT + i, &res); psudata.fitted[i] = psustat & EBUS_PSU_PRESENT; psudata.output[i] = psustat & EBUS_PSU_OUTPUT; psudata.supplyb[i] = psustat & EBUS_PSU_INPUTB; psudata.supplya[i] = psustat & EBUS_PSU_INPUTA; psudata.standby[i] = psustat & EBUS_PSU_STANDBY; } if (ddi_copyout((caddr_t)&psudata, (caddr_t)arg, sizeof (psudata), mode) < 0) { res = EFAULT; } return (res); } /* * LOMIOCFANSTATE - returns full information including speed for 4 * fans and the minimum and maximum operating speeds for each fan as * stored in the READ ONLY EEPROM data. As this EEPROM data is set * at manufacture time, this data should only be read by the driver * once and stored locally. */ static int bscv_ioc_fanstate(bscv_soft_state_t *ssp, intptr_t arg, int mode) { lom_fandata_t fandata; int numfans; int i; int res = 0; bzero(&fandata, sizeof (lom_fandata_t)); numfans = EBUS_CONFIG_NFAN_DEC(bscv_get8_locked(ssp, chan_general, EBUS_IDX_CONFIG, &res)); for (i = 0; (i < numfans) && (res == 0); i++) { if (ssp->fanspeed[i] != LOM_FAN_NOT_PRESENT) { fandata.fitted[i] = 1; fandata.speed[i] = ssp->fanspeed[i]; fandata.minspeed[i] = bscv_get8_cached(ssp, EBUS_IDX_FAN1_LOW + i); } } if ((res == 0) && (ddi_copyout((caddr_t)&fandata, (caddr_t)arg, sizeof (fandata), mode) < 0)) { res = EFAULT; } return (res); } /* * LOMIOCFLEDSTATE - returns the state of the fault LED */ static int bscv_ioc_fledstate(bscv_soft_state_t *ssp, intptr_t arg, int mode) { lom_fled_info_t fled_info; uint8_t fledstate; int res = 0; fledstate = bscv_get8_locked(ssp, chan_general, EBUS_IDX_ALARM, &res); /* Decode of 0x0F is off and 0x00-0x07 is on. */ if (EBUS_ALARM_LED_DEC(fledstate) == 0x0F) { fled_info.on = 0; } else { /* has +1 here - not 2 as in the info ioctl */ fled_info.on = EBUS_ALARM_LED_DEC(fledstate) + 1; } if ((res == 0) && (ddi_copyout((caddr_t)&fled_info, (caddr_t)arg, sizeof (fled_info), mode) < 0)) { res = EFAULT; } return (res); } /* * LOMIOCLEDSTATE - returns the state of the requested LED */ static int bscv_ioc_ledstate(bscv_soft_state_t *ssp, intptr_t arg, int mode) { lom_led_state_t led_state; int fw_led_state; int res = 0; /* copy in arguments supplied */ if (ddi_copyin((caddr_t)arg, (caddr_t)&led_state, sizeof (lom_led_state_t), mode) < 0) { return (EFAULT); } /* * check if led index is -1, if so set it to max value for * this implementation. */ if (led_state.index == -1) { led_state.index = MAX_LED_ID; } /* is the index in a valid range */ if ((led_state.index > MAX_LED_ID) || (led_state.index < 0)) { led_state.state = LOM_LED_OUTOFRANGE; } else { /* read the relevant led info */ fw_led_state = bscv_get8_locked(ssp, chan_general, EBUS_IDX_LED1_STATUS + led_state.index, &res); /* set the state values accordingly */ switch (fw_led_state) { case LOM_LED_STATE_OFF: led_state.state = LOM_LED_OFF; led_state.colour = LOM_LED_COLOUR_ANY; break; case LOM_LED_STATE_ON_STEADY: led_state.state = LOM_LED_ON; led_state.colour = LOM_LED_COLOUR_ANY; break; case LOM_LED_STATE_ON_FLASHING: case LOM_LED_STATE_ON_SLOWFLASH: led_state.state = LOM_LED_BLINKING; led_state.colour = LOM_LED_COLOUR_ANY; break; case LOM_LED_STATE_NOT_PRESENT: led_state.state = LOM_LED_NOT_IMPLEMENTED; led_state.colour = LOM_LED_COLOUR_NONE; break; case LOM_LED_STATE_INACCESSIBLE: case LOM_LED_STATE_STANDBY: default: led_state.state = LOM_LED_ACCESS_ERROR; led_state.colour = LOM_LED_COLOUR_NONE; break; } /* set the label info */ (void) strcpy(led_state.label, ssp->led_names[led_state.index]); } /* copy out lom_state */ if ((res == 0) && (ddi_copyout((caddr_t)&led_state, (caddr_t)arg, sizeof (lom_led_state_t), mode) < 0)) { res = EFAULT; } return (res); } /* * LOMIOCINFO - returns with a structure containing any information * stored on the LOMlite which a user should not need to access but * may be useful for diagnostic problems. The structure contains: the * serial escape character, alarm3 mode, version and checksum read from * RAM and the Product revision and ID read from EEPROM. */ static int bscv_ioc_info(bscv_soft_state_t *ssp, intptr_t arg, int mode) { lom_info_t info; int i; uint16_t csum; int res = 0; info.ser_char = bscv_get8_locked(ssp, chan_general, EBUS_IDX_ESCAPE, &res); info.a3mode = WATCHDOG; info.fver = bscv_get8_locked(ssp, chan_general, EBUS_IDX_FW_REV, &res); csum = bscv_get8_locked(ssp, chan_general, EBUS_IDX_CHECK_HI, &res) << 8; csum |= bscv_get8_locked(ssp, chan_general, EBUS_IDX_CHECK_LO, &res); info.fchksum = csum; info.prod_rev = bscv_get8_locked(ssp, chan_general, EBUS_IDX_MODEL_REV, &res); for (i = 0; i < sizeof (info.prod_id); i++) { info.prod_id[i] = bscv_get8_locked(ssp, chan_general, EBUS_IDX_MODEL_ID1 + i, &res); } if (bscv_get8_locked(ssp, chan_general, EBUS_IDX_ALARM, &res) & EBUS_ALARM_NOEVENTS) { info.events = OFF; } else { info.events = ON; } if ((res == 0) && (ddi_copyout((caddr_t)&info, (caddr_t)arg, sizeof (info), mode) < 0)) { res = EFAULT; } return (res); } /* * LOMIOCMREAD - used to query the LOMlite configuration parameters */ static int bscv_ioc_mread(bscv_soft_state_t *ssp, intptr_t arg, int mode) { lom_mprog_t mprog; int i; int fanz; int res = 0; for (i = 0; i < sizeof (mprog.mod_id); i++) { mprog.mod_id[i] = bscv_get8_locked(ssp, chan_general, EBUS_IDX_MODEL_ID1 + i, &res); } mprog.mod_rev = bscv_get8_locked(ssp, chan_general, EBUS_IDX_MODEL_REV, &res); mprog.config = bscv_get8_locked(ssp, chan_general, EBUS_IDX_CONFIG, &res); /* Read the fan calibration values */ fanz = sizeof (mprog.fanhz) / sizeof (mprog.fanhz[0]); for (i = 0; i < fanz; i++) { mprog.fanhz[i] = bscv_get8_cached(ssp, EBUS_IDX_FAN1_CAL + i); mprog.fanmin[i] = bscv_get8_cached(ssp, EBUS_IDX_FAN1_LOW + i); } if ((res == 0) && (ddi_copyout((caddr_t)&mprog, (caddr_t)arg, sizeof (mprog), mode) < 0)) { res = EFAULT; } return (res); } /* * LOMIOCVOLTS */ static int bscv_ioc_volts(bscv_soft_state_t *ssp, intptr_t arg, int mode) { int i; uint16_t supply; int res = 0; supply = (bscv_get8_locked(ssp, chan_general, EBUS_IDX_SUPPLY_HI, &res) << 8) | bscv_get8_locked(ssp, chan_general, EBUS_IDX_SUPPLY_LO, &res); for (i = 0; i < ssp->volts.num; i++) { ssp->volts.status[i] = (supply >> i) & 1; } if ((res == 0) && (ddi_copyout((caddr_t)&ssp->volts, (caddr_t)arg, sizeof (ssp->volts), mode) < 0)) { res = EFAULT; } return (res); } /* * LOMIOCSTATS */ static int bscv_ioc_stats(bscv_soft_state_t *ssp, intptr_t arg, int mode) { int i; uint8_t status; int res = 0; status = bscv_get8_locked(ssp, chan_general, EBUS_IDX_CBREAK_STATUS, &res); for (i = 0; i < ssp->sflags.num; i++) { ssp->sflags.status[i] = (int)((status >> i) & 1); } if ((res == 0) && (ddi_copyout((caddr_t)&ssp->sflags, (caddr_t)arg, sizeof (ssp->sflags), mode) < 0)) { res = EFAULT; } return (res); } /* * LOMIOCTEMP */ static int bscv_ioc_temp(bscv_soft_state_t *ssp, intptr_t arg, int mode) { int i; int idx; uint8_t status_ov; lom_temp_t temps; int res = 0; bzero(&temps, sizeof (temps)); idx = 0; for (i = 0; i < ssp->temps.num; i++) { if (ssp->temps.temp[i] != LOM_TEMP_STATE_NOT_PRESENT) { temps.temp[idx] = ssp->temps.temp[i]; bcopy(ssp->temps.name[i], temps.name[idx], sizeof (temps.name[idx])); temps.warning[idx] = ssp->temps.warning[i]; temps.shutdown[idx] = ssp->temps.shutdown[i]; idx++; } } temps.num = idx; bcopy(ssp->temps.name_ov, temps.name_ov, sizeof (temps.name_ov)); temps.num_ov = ssp->temps.num_ov; status_ov = bscv_get8_locked(ssp, chan_general, EBUS_IDX_OTEMP_STATUS, &res); for (i = 0; i < ssp->temps.num_ov; i++) { ssp->temps.status_ov[i] = (status_ov >> i) & 1; } if ((res == 0) && (ddi_copyout((caddr_t)&temps, (caddr_t)arg, sizeof (temps), mode) < 0)) { res = EFAULT; } return (res); } /* * LOMIOCCONS */ static int bscv_ioc_cons(bscv_soft_state_t *ssp, intptr_t arg, int mode) { lom_cbuf_t cbuf; int datasize; int res = 0; bzero(&cbuf, sizeof (cbuf)); datasize = EBUS_IDX1_CONS_BUF_END - EBUS_IDX1_CONS_BUF_START + 1; /* Ensure that we do not overfill cbuf and that it is NUL terminated */ if (datasize > (sizeof (cbuf) - 1)) { datasize = sizeof (cbuf) - 1; } bscv_rep_get8_locked(ssp, chan_general, (uint8_t *)cbuf.lrbuf, BSCVA(EBUS_CMD_SPACE1, (EBUS_IDX1_CONS_BUF_END - datasize + 1)), datasize, DDI_DEV_AUTOINCR, &res); /* This is always within the array due to the checks above */ cbuf.lrbuf[datasize] = '\0'; if ((res == 0) && (ddi_copyout((caddr_t)&cbuf, (caddr_t)arg, sizeof (cbuf), mode) < 0)) { res = EFAULT; } return (res); } /* * LOMIOCEVENTLOG2 */ static int bscv_ioc_eventlog2(bscv_soft_state_t *ssp, intptr_t arg, int mode) { lom_eventlog2_t *eventlog2; int events_recorded; int level; uint16_t next_offset; lom_event_t event; int res = 0; eventlog2 = (lom_eventlog2_t *)kmem_zalloc(sizeof (*eventlog2), KM_SLEEP); /* * First get number of events and level requested. */ if (ddi_copyin((caddr_t)arg, (caddr_t)eventlog2, sizeof (lom_eventlog2_t), mode) < 0) { kmem_free((void *)eventlog2, sizeof (*eventlog2)); return (EFAULT); } bscv_enter(ssp); /* * OK we have full private access to the LOM now so loop * over the eventlog addr spaces until we get the required * number of events. */ if (!bscv_window_setup(ssp)) { res = EIO; bscv_exit(ssp); kmem_free((void *)eventlog2, sizeof (*eventlog2)); return (res); } /* * Read count, next event ptr MSB,LSB. Note a read of count * is necessary to latch values for the next event ptr */ (void) bscv_get8(ssp, chan_general, EBUS_IDX_UNREAD_EVENTS); next_offset = bscv_get16(ssp, chan_general, EBUS_IDX_LOG_PTR_HI); bscv_trace(ssp, 'I', "bscv_ioc_eventlog2", "log_ptr_hi 0x%x", next_offset); events_recorded = 0; while (events_recorded < eventlog2->num) { /* * Working backwards - read an event at a time. * next_offset is one event on from where we want to be! * Decrement next_offset and maybe wrap to the end of the * buffer. * Note the unsigned arithmetic, so check values first! */ if (next_offset <= ssp->eventlog_start) { /* Wrap to the end of the buffer */ next_offset = ssp->eventlog_start + ssp->eventlog_size; bscv_trace(ssp, 'I', "bscv_ioc_eventlog2", "wrapping" " around to end of buffer; next_offset 0x%x", next_offset); } next_offset -= sizeof (event); if (bscv_eerw(ssp, next_offset, (uint8_t *)&event, sizeof (event), B_FALSE /* read */) != 0) { /* Fault reading data - stop */ bscv_trace(ssp, 'I', "bscv_ioc_eventlog2", "read" " failure for offset 0x%x", next_offset); res = EIO; break; } if (bscv_is_null_event(ssp, &event)) { /* * No more events in this log so give up. */ bscv_trace(ssp, 'I', "bscv_ioc_eventlog2", "no more" " events left at offset 0x%x", next_offset); break; } /* * Are we interested in this event */ level = bscv_level_of_event(&event); if (level <= eventlog2->level) { /* Arggh why the funny byte ordering 3, 2, 0, 1 */ eventlog2->code[events_recorded] = ((unsigned)event.ev_event | ((unsigned)event.ev_subsys << 8) | ((unsigned)event.ev_resource << 16) | ((unsigned)event.ev_detail << 24)); eventlog2->time[events_recorded] = ((unsigned)event.ev_data[0] | ((unsigned)event.ev_data[1] << 8) | ((unsigned)event.ev_data[3] << 16) | ((unsigned)event.ev_data[2] << 24)); bscv_build_eventstring(ssp, &event, eventlog2->string[events_recorded], eventlog2->string[events_recorded] + sizeof (eventlog2->string[events_recorded])); events_recorded++; } } eventlog2->num = events_recorded; bscv_exit(ssp); if ((res == 0) && (ddi_copyout((caddr_t)eventlog2, (caddr_t)arg, sizeof (lom_eventlog2_t), mode) < 0)) { res = EFAULT; } kmem_free((void *)eventlog2, sizeof (lom_eventlog2_t)); return (res); } /* * LOMIOCINFO2 */ static int bscv_ioc_info2(bscv_soft_state_t *ssp, intptr_t arg, int mode) { lom2_info_t info2; int i; uint16_t csum; int res = 0; bzero(&info2, sizeof (info2)); (void) strncpy(info2.escape_chars, ssp->escape_chars, sizeof (info2.escape_chars)); info2.serial_events = ssp->reporting_level | ssp->serial_reporting; info2.a3mode = WATCHDOG; info2.fver = bscv_get8_locked(ssp, chan_general, EBUS_IDX_FW_REV, &res); csum = bscv_get8_locked(ssp, chan_general, EBUS_IDX_CHECK_HI, &res) << 8; csum |= bscv_get8_locked(ssp, chan_general, EBUS_IDX_CHECK_LO, &res); info2.fchksum = csum; info2.prod_rev = bscv_get8_locked(ssp, chan_general, EBUS_IDX_MODEL_REV, &res); for (i = 0; i < sizeof (info2.prod_id); i++) { info2.prod_id[i] = bscv_get8_locked(ssp, chan_general, EBUS_IDX_MODEL_ID1 + i, &res); } info2.serial_config = bscv_get8_locked(ssp, chan_general, EBUS_IDX_SER_TIMEOUT, &res); if (bscv_get8_locked(ssp, chan_general, EBUS_IDX_CONFIG_MISC, &res) & EBUS_CONFIG_MISC_SECURITY_ENABLED) { info2.serial_config |= LOM_SER_SECURITY; } if (bscv_get8_locked(ssp, chan_general, EBUS_IDX_CONFIG_MISC, &res) & EBUS_CONFIG_MISC_AUTO_CONSOLE) { info2.serial_config |= LOM_SER_RETURN; } if (bscv_get8_locked(ssp, chan_general, EBUS_IDX_WDOG_CTRL, &res) & EBUS_WDOG_BREAK_DISABLE) { info2.serial_config |= LOM_DISABLE_WDOG_BREAK; } info2.baud_rate = bscv_get8_locked(ssp, chan_general, EBUS_IDX_SER_BAUD, &res); info2.serial_hw_config = ((int)bscv_get8_locked(ssp, chan_general, EBUS_IDX_SER_CHARMODE, &res) | ((int)bscv_get8_locked(ssp, chan_general, EBUS_IDX_SER_FLOWCTL, &res) << 8) | ((int)bscv_get8_locked(ssp, chan_general, EBUS_IDX_SER_MODEMTYPE, &res) << 16)); /* * There is no phone home support on the blade platform. We hardcode * FALSE and NUL for config and script respectively. */ info2.phone_home_config = B_FALSE; info2.phone_home_script[0] = '\0'; for (i = 0; i < ssp->num_fans; i++) { (void) strcpy(info2.fan_names[i], ssp->fan_names[i]); } if ((res == 0) && (ddi_copyout((caddr_t)&info2, (caddr_t)arg, sizeof (info2), mode) < 0)) { res = EFAULT; } return (res); } /* * LOMIOCTEST */ static int bscv_ioc_test(bscv_soft_state_t *ssp, intptr_t arg, int mode) { uint32_t test; uint8_t testnum; uint8_t testarg; int res = 0; if (ddi_copyin((caddr_t)arg, (caddr_t)&test, sizeof (test), mode) < 0) { return (EFAULT); } /* * Extract num iterations. */ testarg = (test & 0xff00) >> 8; testnum = test & 0xff; bscv_trace(ssp, 'F', "bscv_ioc_test", "LOMIOCTEST data 0x%x (test 0x%x, arg 0x%x)", test, (EBUS_IDX_SELFTEST0 + testnum), testarg); switch (testnum + EBUS_IDX_SELFTEST0) { default: /* Invalid test */ res = EINVAL; break; case EBUS_IDX_SELFTEST0: /* power on self-test result */ case EBUS_IDX_SELFTEST1: /* not used currently */ case EBUS_IDX_SELFTEST2: /* not used currently */ case EBUS_IDX_SELFTEST3: /* not used currently */ case EBUS_IDX_SELFTEST4: /* not used currently */ case EBUS_IDX_SELFTEST5: /* not used currently */ case EBUS_IDX_SELFTEST6: /* LED self-test */ case EBUS_IDX_SELFTEST7: /* platform-specific tests */ /* Run the test */ /* Stop other things and then run the test */ bscv_enter(ssp); /* * Then we simply write the argument to the relevant register * and wait for the return code. */ bscv_put8(ssp, chan_general, EBUS_IDX_SELFTEST0 + testnum, testarg); if (bscv_faulty(ssp)) { res = EIO; } else { /* Get hold of the SunVTS error code */ test = bscv_retcode(ssp); } bscv_exit(ssp); break; } bscv_trace(ssp, 'F', "bscv_ioc_test", "LOMIOCTEST status 0x%x, res 0x%x", test, res); if ((res == 0) && (ddi_copyout((caddr_t)&test, (caddr_t)arg, sizeof (test), mode) < 0)) { res = EFAULT; } return (res); } /* * LOMIOCMPROG2 */ static int bscv_ioc_mprog2(bscv_soft_state_t *ssp, intptr_t arg, int mode) { lom2_mprog_t mprog2; uint32_t base_addr; uint32_t data_size; uint32_t eeprom_size; int res = 0; if (ddi_copyin((caddr_t)arg, (caddr_t)&mprog2, sizeof (mprog2), mode) < 0) { return (EFAULT); } /* * Note that originally this was accessed as 255 byte pages * in address spaces 240-255. We have to emulate this behaviour. */ if ((mprog2.addr_space < 240) || (mprog2.addr_space > 255)) { return (EINVAL); } bscv_enter(ssp); /* Calculate required data location */ data_size = 255; base_addr = (mprog2.addr_space - 240) * data_size; eeprom_size = bscv_get8(ssp, chan_general, EBUS_IDX_EEPROM_SIZE_KB) * 1024; if (bscv_faulty(ssp)) { bscv_exit(ssp); return (EIO); } else if ((base_addr + data_size) > eeprom_size) { bscv_trace(ssp, 'M', "bscv_ioc_mprog2", "Request extends past end of eeprom"); bscv_exit(ssp); return (ENXIO); } bscv_put8(ssp, chan_general, EBUS_IDX_CMD_RES, EBUS_CMD_UNLOCK1); if (bscv_faulty(ssp)) { bscv_trace(ssp, 'M', "bscv_ioc_mprog2", "ML1 Write failed"); bscv_exit(ssp); return (EIO); } bscv_put8(ssp, chan_general, EBUS_IDX_CMD_RES, EBUS_CMD_UNLOCK2); if (bscv_faulty(ssp)) { bscv_trace(ssp, 'M', "bscv_ioc_mprog2", "ML2 Write failed"); bscv_exit(ssp); return (EIO); } if (bscv_eerw(ssp, base_addr, &mprog2.data[0], data_size, B_TRUE /* write */) != 0) { res = EIO; } /* Read a probe key to release the lock. */ (void) bscv_get8(ssp, chan_general, EBUS_IDX_PROBEAA); if (bscv_faulty(ssp)) { res = EIO; } bscv_exit(ssp); return (res); } /* * LOMIOCMREAD2 */ static int bscv_ioc_mread2(bscv_soft_state_t *ssp, intptr_t arg, int mode) { lom2_mprog_t mprog2; uint32_t base_addr; uint32_t data_size; uint32_t eeprom_size; int res = 0; if (ddi_copyin((caddr_t)arg, (caddr_t)&mprog2, sizeof (mprog2), mode) < 0) { return (EFAULT); } /* * Need to stop the queue and then just read * the bytes blind to the relevant addresses. * Note that originally this was accessed as 255 byte pages * in address spaces 240-255. We have to emulate this behaviour. */ if ((mprog2.addr_space < 240) || (mprog2.addr_space > 255)) { return (EINVAL); } bscv_enter(ssp); /* Calculate required data location */ data_size = 255; base_addr = (mprog2.addr_space - 240) * data_size; eeprom_size = bscv_get8(ssp, chan_general, EBUS_IDX_EEPROM_SIZE_KB) * 1024; if (bscv_faulty(ssp)) { bscv_exit(ssp); return (EIO); } else if ((base_addr + data_size) > eeprom_size) { bscv_trace(ssp, 'M', "bscv_ioc_mread2", "Request extends past end of eeprom"); bscv_exit(ssp); return (ENXIO); } if (bscv_eerw(ssp, base_addr, &mprog2.data[0], data_size, B_FALSE /* read */) != 0) { res = EIO; } if (bscv_faulty(ssp)) { res = EIO; } bscv_exit(ssp); if ((res == 0) && (ddi_copyout((caddr_t)&mprog2, (caddr_t)arg, sizeof (mprog2), mode) < 0)) { res = EFAULT; } return (res); } static void bscv_get_state_changes(bscv_soft_state_t *ssp) { int i = STATUS_READ_LIMIT; uint8_t change; uint8_t detail; ASSERT(bscv_held(ssp)); while (i-- && !ssp->cssp_prog) { /* Are there any changes to process? */ change = bscv_get8(ssp, chan_general, EBUS_IDX_STATE_CHNG); change &= EBUS_STATE_MASK; if (!change) break; /* Clarify the pending change */ detail = bscv_get8(ssp, chan_general, EBUS_IDX_EVENT_DETAIL); bscv_status(ssp, change, detail); } bscv_trace(ssp, 'D', "bscv_get_state_changes", "loop index %d ssp->cssp_prog 0x%x", i, ssp->cssp_prog); } /* * ********************************************************************* * Event Processing * ********************************************************************* */ /* * function - bscv_event_daemon * description - Perform periodic lom tasks in a separate thread. * inputs - LOM soft state structure pointer * outputs - none. */ static void bscv_event_daemon(void *arg) { bscv_soft_state_t *ssp = (void *)arg; boolean_t do_events; boolean_t do_status; boolean_t do_nodename; boolean_t do_watchdog; uint32_t async_reg; uint32_t fault; clock_t poll_period = BSC_EVENT_POLL_NORMAL; int fault_cnt = 0; bscv_trace(ssp, 'D', "bscv_event_daemon", "bscv_event_daemon: started"); /* Acquire task daemon lock. */ mutex_enter(&ssp->task_mu); ssp->task_flags |= TASK_ALIVE_FLG; for (;;) { if ((ssp->task_flags & TASK_STOP_FLG) != 0) { /* Stop request seen - terminate */ break; } if ((ssp->task_flags & TASK_PAUSE_FLG) == 0) { /* Poll for events reported to the nexus */ mutex_exit(&ssp->task_mu); /* Probe and Check faults */ bscv_enter(ssp); async_reg = bscv_probe(ssp, chan_general, &fault); bscv_trace(ssp, 'D', "bscv_event_daemon", "process event: async_reg 0x%x, fault 0x%x", async_reg, fault); if (!fault) { /* Treat non-fault conditions */ if (ssp->cssp_prog || ssp->prog_mode_only) { /* * The BSC has become available again. */ fault_cnt = 0; ssp->cssp_prog = B_FALSE; ssp->prog_mode_only = B_FALSE; (void) bscv_attach_common(ssp); } else if (fault_cnt > 0) { /* Previous fault has cleared */ bscv_clear_fault(ssp); fault_cnt = 0; cmn_err(CE_WARN, "!bscv_event_daemon previous fault " "cleared."); } else if (bscv_faulty(ssp)) { /* Previous fault has cleared */ bscv_clear_fault(ssp); /* Sleep to avoid busy waiting */ ssp->event_sleep = B_TRUE; } poll_period = BSC_EVENT_POLL_NORMAL; if (async_reg) { ssp->status_change = B_TRUE; ssp->event_waiting = B_TRUE; } } else if (ssp->cssp_prog) { /* * Expect radio silence or error values * when the CSSP is upgrading the BSC firmware * so throw away any fault indication. */ fault = B_FALSE; } else if (fault_cnt == BSC_PROBE_FAULT_LIMIT) { /* Count previous faults and maybe fail */ /* Declare the lom broken */ bscv_set_fault(ssp); poll_period = BSC_EVENT_POLL_FAULTY; cmn_err(CE_WARN, "!bscv_event_daemon had faults probing " "lom - marking it as faulty."); /* * Increment fault_cnt to ensure that * next time we do not report a message * i.e. we drop out of the bottom */ fault_cnt = BSC_PROBE_FAULT_LIMIT + 1; ssp->event_sleep = B_TRUE; } else if (fault_cnt < BSC_PROBE_FAULT_LIMIT) { if (bscv_faulty(ssp)) { poll_period = BSC_EVENT_POLL_FAULTY; /* * No recovery messages in this case * because there was never a fault * message here. */ fault_cnt = 0; } else { /* Getting ready to explode */ fault_cnt++; cmn_err(CE_WARN, "!bscv_event_daemon had fault 0x%x", fault); } ssp->event_sleep = B_TRUE; } bscv_exit(ssp); mutex_enter(&ssp->task_mu); } #if defined(__i386) || defined(__amd64) /* * we have no platmod hook on Solaris x86 to report * a change to the nodename so we keep a copy so * we can detect a change and request that the bsc * be updated when appropriate. */ if (strcmp(ssp->last_nodename, utsname.nodename) != 0) { bscv_trace(ssp, 'X', "bscv_event_daemon", "utsname.nodename='%s' possible change detected", utsname.nodename); ssp->nodename_change = B_TRUE; (void) strncpy(ssp->last_nodename, utsname.nodename, sizeof (ssp->last_nodename)); /* enforce null termination */ ssp->last_nodename[sizeof (ssp->last_nodename) - 1] = '\0'; } #endif /* __i386 || __amd64 */ if (((ssp->task_flags & TASK_PAUSE_FLG) == 0) && fault_cnt == 0 && ssp->cssp_prog == B_FALSE && (ssp->event_waiting || ssp->status_change || ssp->nodename_change || ssp->watchdog_change)) { do_events = ssp->event_waiting; ssp->event_waiting = B_FALSE; ssp->task_flags |= do_events ? TASK_EVENT_PENDING_FLG : 0; do_status = ssp->status_change; ssp->status_change = B_FALSE; do_nodename = ssp->nodename_change; ssp->nodename_change = B_FALSE; do_watchdog = ssp->watchdog_change; if (ssp->watchdog_change) { ssp->watchdog_change = B_FALSE; } mutex_exit(&ssp->task_mu); /* * We must not hold task_mu whilst processing * events because this can lead to priority * inversion and hence our interrupts getting * locked out. */ bscv_enter(ssp); if (do_events) { bscv_event_process(ssp, do_events); } if (do_nodename) { bscv_trace(ssp, 'D', "bscv_event_daemon", "do_nodename task"); bscv_setup_hostname(ssp); } if (do_watchdog) { bscv_trace(ssp, 'D', "bscv_event_daemon", "do_watchdog task"); bscv_setup_watchdog(ssp); } /* * Pending status changes are dealt with last because * if we see that the BSC is about to be programmed, * then it will expect us to to quiescent in the * first second so it can cleanly tear down its comms * protocols; this takes ~100 ms. */ if (do_status) { bscv_get_state_changes(ssp); } if (bscv_session_error(ssp)) { /* * Had fault during event session. We always * sleep after one of these because there * may be a problem with the lom which stops * us doing useful work in the event daemon. * If we don't sleep then we may livelock. */ bscv_trace(ssp, 'D', "bscv_event_daemon", "had session error - sleeping"); ssp->event_sleep = B_TRUE; } bscv_exit(ssp); mutex_enter(&ssp->task_mu); if (ssp->task_flags & TASK_EVENT_PENDING_FLG) { /* * We have read any events which were * pending. Let the consumer continue. * Ignore the race condition with new events * arriving - just let the consumer have * whatever was pending when they asked. */ ssp->event_active_count++; ssp->task_flags &= ~(TASK_EVENT_PENDING_FLG | TASK_EVENT_CONSUMER_FLG); cv_broadcast(&ssp->task_evnt_cv); } } else { /* There was nothing to do - sleep */ ssp->event_sleep = B_TRUE; } if (ssp->event_sleep) { ssp->task_flags |= TASK_SLEEPING_FLG; /* Sleep until there is something to do */ (void) cv_timedwait(&ssp->task_cv, &ssp->task_mu, poll_period + ddi_get_lbolt()); ssp->task_flags &= ~TASK_SLEEPING_FLG; ssp->event_sleep = B_FALSE; } } if (ssp->task_flags & TASK_EVENT_CONSUMER_FLG) { /* * We are going away so wake up any event consumer. * Pretend that any pending events have been processed. */ ssp->event_active_count += 2; cv_broadcast(&ssp->task_evnt_cv); } ASSERT(!(ssp->task_flags & TASK_EVENT_PENDING_FLG)); ssp->task_flags &= ~(TASK_STOP_FLG | TASK_ALIVE_FLG | TASK_EVENT_CONSUMER_FLG); mutex_exit(&ssp->task_mu); bscv_trace(ssp, 'D', "bscv_event_daemon", "exiting."); } /* * function - bscv_start_event_daemon * description - Create the event daemon thread. * inputs - LOM soft state structure pointer * outputs - none */ static void bscv_start_event_daemon(bscv_soft_state_t *ssp) { if (ssp->progress & BSCV_THREAD) return; /* Start the event thread after the queue has started */ (void) thread_create(NULL, 0, (void (*)())bscv_event_daemon, ssp, 0, &p0, TS_RUN, minclsyspri); ssp->progress |= BSCV_THREAD; } /* * function - bscv_stop_event_daemon * description - Attempt to stop the event daemon thread. * inputs - LOM soft state structure pointer * outputs - DDI_SUCCESS OR DDI_FAILURE */ static int bscv_stop_event_daemon(bscv_soft_state_t *ssp) { int try; int res = DDI_SUCCESS; mutex_enter(&ssp->task_mu); /* Wait for task daemon to stop running. */ for (try = 0; ((ssp->task_flags & TASK_ALIVE_FLG) && try < 10); try++) { /* Signal that the task daemon should stop */ ssp->task_flags |= TASK_STOP_FLG; cv_signal(&ssp->task_cv); /* Release task daemon lock. */ mutex_exit(&ssp->task_mu); /* * TODO - when the driver is modified to support * system suspend or if this routine gets called * during panic we should use drv_usecwait() rather * than delay in those circumstances. */ delay(drv_usectohz(1000000)); mutex_enter(&ssp->task_mu); } if (ssp->task_flags & TASK_ALIVE_FLG) { res = DDI_FAILURE; } mutex_exit(&ssp->task_mu); return (res); } /* * function - bscv_pause_event_daemon * description - Attempt to pause the event daemon thread. * inputs - LOM soft state structure pointer * outputs - DDI_SUCCESS OR DDI_FAILURE */ static int bscv_pause_event_daemon(bscv_soft_state_t *ssp) { int try; if (!(ssp->progress & BSCV_THREAD)) { /* Nothing to do */ return (BSCV_SUCCESS); } bscv_trace(ssp, 'D', "bscv_pause_event_daemon", "Attempting to pause event daemon"); mutex_enter(&ssp->task_mu); /* Signal that the task daemon should pause */ ssp->task_flags |= TASK_PAUSE_FLG; /* Wait for task daemon to pause. */ for (try = 0; (!(ssp->task_flags & TASK_SLEEPING_FLG) && (ssp->task_flags & TASK_ALIVE_FLG) && try < 10); try++) { /* Paranoia */ ssp->task_flags |= TASK_PAUSE_FLG; cv_signal(&ssp->task_cv); /* Release task daemon lock. */ mutex_exit(&ssp->task_mu); delay(drv_usectohz(1000000)); mutex_enter(&ssp->task_mu); } if ((ssp->task_flags & TASK_SLEEPING_FLG) || !(ssp->task_flags & TASK_ALIVE_FLG)) { mutex_exit(&ssp->task_mu); bscv_trace(ssp, 'D', "bscv_pause_event_daemon", "Pause event daemon - success"); return (BSCV_SUCCESS); } mutex_exit(&ssp->task_mu); bscv_trace(ssp, 'D', "bscv_pause_event_daemon", "Pause event daemon - failed"); return (BSCV_FAILURE); } /* * function - bscv_resume_event_daemon * description - Resumethe event daemon thread. * inputs - LOM soft state structure pointer * outputs - None. */ static void bscv_resume_event_daemon(bscv_soft_state_t *ssp) { if (!(ssp->progress & BSCV_THREAD)) { /* Nothing to do */ return; } mutex_enter(&ssp->task_mu); /* Allow the task daemon to resume event processing */ ssp->task_flags &= ~TASK_PAUSE_FLG; cv_signal(&ssp->task_cv); mutex_exit(&ssp->task_mu); bscv_trace(ssp, 'D', "bscv_pause_event_daemon", "Event daemon resumed"); } /* * function - bscv_event_process * description - process (report) events * inputs - Soft state ptr, process event request * outputs - none */ static void bscv_event_process(bscv_soft_state_t *ssp, boolean_t do_events) { uint32_t currptr; unsigned int count; /* Raw values read from the lom */ uint8_t evcount; uint16_t logptr; lom_event_t event; if (do_events) { /* * Read count, next event ptr MSB,LSB. Note a read of count * latches values for the next event ptr */ evcount = bscv_get8(ssp, chan_general, EBUS_IDX_UNREAD_EVENTS); logptr = bscv_get16(ssp, chan_general, EBUS_IDX_LOG_PTR_HI); /* Sanity check the values from the lom */ count = bscv_event_validate(ssp, logptr, evcount); if (count == -1) { /* * Nothing to do - or badly configured event log. * We really do not want to touch the lom in this * case because any data that we access may be bad! * This differs from zero because if we have zero * to read the lom probably things that unread is * non-zero and we want that to be set to zero! * Signal event fault to make the thread wait * before attempting to re-read the log. */ ssp->event_sleep = B_TRUE; goto logdone; } if (ssp->event_fault_reported) { /* Clear down any old status - things are fixed */ cmn_err(CE_NOTE, "Event pointer fault recovered."); ssp->event_fault_reported = B_FALSE; } /* Compute the first entry that we need to read. */ currptr = logptr - ssp->eventlog_start; currptr += ssp->eventlog_size; currptr -= (count * sizeof (event)); currptr %= ssp->eventlog_size; currptr += ssp->eventlog_start; bscv_trace(ssp, 'E', "bscv_event_process", "processing %d events from 0x%x in 0x%x:0x%x", count, currptr, ssp->eventlog_start, ssp->eventlog_start + ssp->eventlog_size); for (; count > 0; count--) { /* Ensure window is positioned correctly */ if (bscv_eerw(ssp, currptr, (uint8_t *)&event, sizeof (event), B_FALSE /* read */) != 0) { /* Fault reading data - stop */ break; } bscv_event_process_one(ssp, &event); bscv_sysevent(ssp, &event); currptr += sizeof (event); if (currptr >= ssp->eventlog_start + ssp->eventlog_size) { currptr = ssp->eventlog_start; } } /* * Clear event count - write the evcount value to remove that * many from the unread total. * Adjust the value to reflect how many we have left to * read just in case we had a failure reading events. */ if (count == 0) { /*EMPTY*/ ASSERT(logptr == currptr); } else if (count > evcount) { evcount = 0; } else { evcount -= count; } bscv_put8(ssp, chan_general, EBUS_IDX_UNREAD_EVENTS, evcount); /* Remember where we were for next time */ ssp->oldeeptr = currptr; ssp->oldeeptr_valid = B_TRUE; logdone: ; } } /* * function - bscv_event_validate * description - validate the event data supplied by the lom and determine * how many (if any) events to read. * This function performs complex checks to ensure that * events are not lost due to lom resets or host resets. * A combination of lom reset and host reset (i.e. power fail) * may cause some events to not be reported. * inputs - Soft state ptr, next event pointer, number of unread events. * outputs - the number of events to read. -1 on error. * zero is a valid value because it forces the loms unread * count to be cleared. */ static int bscv_event_validate(bscv_soft_state_t *ssp, uint32_t newptr, uint8_t unread) { uint32_t oldptr; unsigned int count; if (!bscv_window_setup(ssp)) { /* Problem with lom eeprom setup we cannot do anything */ return (-1); } /* Sanity check the event pointers */ if ((newptr < ssp->eventlog_start) || (newptr >= (ssp->eventlog_start + ssp->eventlog_size))) { if (!ssp->event_fault_reported) { cmn_err(CE_WARN, "Event pointer out of range. " "Cannot read events."); ssp->event_fault_reported = B_TRUE; } return (-1); } oldptr = ssp->oldeeptr; /* Now sanity check log pointer against count */ if (newptr < oldptr) { /* * Must have wrapped add eventlog_size to get the * correct relative values - this makes the checks * below work! */ newptr += ssp->eventlog_size; } if (!ssp->oldeeptr_valid) { /* We have just started up - we have to trust lom */ count = unread; } else if ((unread == 0) && (newptr == oldptr)) { /* Nothing to do - we were just polling */ return (-1); } else if (oldptr + (unread * sizeof (lom_event_t)) == newptr) { /* Ok - got as many events as we expected */ count = unread; } else if (oldptr + (unread * sizeof (lom_event_t)) > newptr) { /* * Errrm more messages than there should have been. * Possible causes: * 1. the event log has filled - we have been * away for a long time * 2. software bug in lom or driver. * 3. something that I haven't thought of! * Always warn about this we should really never * see it! */ count = (newptr - oldptr) / sizeof (lom_event_t); bscv_trace(ssp, 'E', "bscv_event_process", "bscv_event_process: lom reported " "more events (%d) than expected (%d).", unread, count); cmn_err(CE_CONT, "only processing %d events", count); } else { /* Less messages - perhaps the lom has been reset */ count = (newptr - oldptr) / sizeof (lom_event_t); bscv_trace(ssp, 'E', "bscv_event_process", "lom reported less events (%d) than expected (%d)" " - the lom may have been reset", unread, count); } /* Whatever happens only read a maximum of 255 entries */ if ((count >= 0xff)) { cmn_err(CE_WARN, "bscv_event_process: too many events (%d) to " "process - some may have been lost", count); count = 0xff; } return (count); } /* * function - bscv_event_process_one * description - reports on state changes to the host. * * inputs - LOM soft state structure pointer. * * outputs - none. */ static void bscv_event_process_one(bscv_soft_state_t *ssp, lom_event_t *event) { int level; char eventstr[100]; int msg_type = 0; if (bscv_is_null_event(ssp, event)) { /* Cleared entry - do not report it */ return; } level = bscv_level_of_event(event); switch (level) { default: msg_type = CE_NOTE; break; case EVENT_LEVEL_FATAL: case EVENT_LEVEL_FAULT: msg_type = CE_WARN; break; } bscv_build_eventstring(ssp, event, eventstr, eventstr + sizeof (eventstr)); if (level <= ssp->reporting_level) { /* * The message is important enough to be shown on the console * as well as the log. */ cmn_err(msg_type, "%s", eventstr); } else { /* * The message goes only to the log. */ cmn_err(msg_type, "!%s", eventstr); } } /* * time formats * * The BSC represents times as seconds since epoch 1970. Currently it gives * us 32 bits, unsigned. In the future this might change to a 64-bit count, * to allow a greater range. * * Timestamp values below BSC_TIME_SANITY do not represent an absolute time, * but instead represent an offset from the last reset. This must be * borne in mind by output routines. */ typedef uint32_t bsctime_t; #define BSC_TIME_SANITY 1000000000 /* * render a formatted time for display */ static size_t bscv_event_snprintgmttime(char *buf, size_t bufsz, todinfo_t t) { int year; /* tod_year is base 1900 so this code needs to adjust */ year = 1900 + t.tod_year; return (snprintf(buf, bufsz, "%04d-%02d-%02d %02d:%02d:%02dZ", year, t.tod_month, t.tod_day, t.tod_hour, t.tod_min, t.tod_sec)); } /* * function - bscv_build_eventstring * description - reports on state changes to the host. * * inputs - LOM soft state structure pointer. * * outputs - none. */ static void bscv_build_eventstring(bscv_soft_state_t *ssp, lom_event_t *event, char *buf, char *bufend) { uint8_t subsystem; uint8_t eventtype; bsctime_t bsctm; bscv_trace(ssp, 'S', "bscv_build_eventstring", "event %2x%2x%2x%2x", event->ev_subsys, event->ev_event, event->ev_resource, event->ev_detail); bscv_trace(ssp, 'S', "bscv_build_eventstring", "time %2x%2x%2x%2x", event->ev_data[0], event->ev_data[1], event->ev_data[2], event->ev_data[3]); /* * We accept bad subsystems and event type codes here. * The code decodes as much as possible and then produces * suitable output. */ subsystem = EVENT_DECODE_SUBSYS(event->ev_subsys); eventtype = event->ev_event; /* time */ bsctm = (((uint32_t)event->ev_data[0]) << 24) | (((uint32_t)event->ev_data[1]) << 16) | (((uint32_t)event->ev_data[2]) << 8) | ((uint32_t)event->ev_data[3]); if (bsctm < BSC_TIME_SANITY) { /* offset */ buf += snprintf(buf, bufend-buf, "+P%dd%02dh%02dm%02ds", (int)(bsctm/86400), (int)(bsctm/3600%24), (int)(bsctm/60%60), (int)(bsctm%60)); } else { /* absolute time */ mutex_enter(&tod_lock); buf += bscv_event_snprintgmttime(buf, bufend-buf, utc_to_tod(bsctm)); mutex_exit(&tod_lock); } buf += snprintf(buf, bufend-buf, " "); /* subsysp */ if (subsystem < (sizeof (eventSubsysStrings)/sizeof (*eventSubsysStrings))) { buf += snprintf(buf, bufend - buf, "%s", eventSubsysStrings[subsystem]); } else { buf += snprintf(buf, bufend - buf, "unknown subsystem %d ", subsystem); } /* resource */ switch (subsystem) { case EVENT_SUBSYS_ALARM: case EVENT_SUBSYS_TEMP: case EVENT_SUBSYS_OVERTEMP: case EVENT_SUBSYS_FAN: case EVENT_SUBSYS_SUPPLY: case EVENT_SUBSYS_BREAKER: case EVENT_SUBSYS_PSU: buf += snprintf(buf, bufend - buf, "%d ", event->ev_resource); break; case EVENT_SUBSYS_LED: buf += snprintf(buf, bufend - buf, "%s ", bscv_get_label( ssp->led_names, MAX_LED_ID, event->ev_resource - 1)); break; default: break; } /* fatal */ if (event->ev_subsys & EVENT_MASK_FAULT) { if (event->ev_subsys & EVENT_MASK_FATAL) { buf += snprintf(buf, bufend - buf, "FATAL FAULT: "); } else { buf += snprintf(buf, bufend - buf, "FAULT: "); } } /* eventp */ if (eventtype < (sizeof (eventTypeStrings)/sizeof (*eventTypeStrings))) { buf += snprintf(buf, bufend - buf, "%s", eventTypeStrings[eventtype]); } else { buf += snprintf(buf, bufend - buf, "unknown event 0x%02x%02x%02x%02x", event->ev_subsys, event->ev_event, event->ev_resource, event->ev_detail); } /* detail */ switch (subsystem) { case EVENT_SUBSYS_TEMP: if ((eventtype != EVENT_RECOVERED) && eventtype != EVENT_DEVICE_INACCESSIBLE) { buf += snprintf(buf, bufend - buf, " - %d degC", (int8_t)event->ev_detail); } break; case EVENT_SUBSYS_FAN: if (eventtype == EVENT_FAILED) { buf += snprintf(buf, bufend - buf, " %d%%", event->ev_detail); } break; case EVENT_SUBSYS_LOM: switch (eventtype) { case EVENT_FLASH_DOWNLOAD: buf += snprintf(buf, bufend - buf, ": v%d.%d to v%d.%d", (event->ev_resource >> 4), (event->ev_resource & 0x0f), (event->ev_detail >> 4), (event->ev_detail & 0x0f)); break; case EVENT_WATCHDOG_TRIGGER: buf += snprintf(buf, bufend - buf, event->ev_detail ? "- soft" : " - hard"); break; case EVENT_UNEXPECTED_RESET: if (event->ev_detail & LOM_UNEXPECTEDRESET_MASK_BADTRAP) { buf += snprintf(buf, bufend - buf, " - unclaimed exception 0x%x", event->ev_detail & ~LOM_UNEXPECTEDRESET_MASK_BADTRAP); } break; case EVENT_RESET: switch (event->ev_detail) { case LOM_RESET_DETAIL_BYUSER: buf += snprintf(buf, bufend - buf, " by user"); break; case LOM_RESET_DETAIL_REPROGRAMMING: buf += snprintf(buf, bufend - buf, " after flash download"); break; default: buf += snprintf(buf, bufend - buf, " - unknown reason"); break; } break; default: break; } break; case EVENT_SUBSYS_LED: switch (event->ev_detail) { case LOM_LED_STATE_OFF: buf += snprintf(buf, bufend - buf, ": OFF"); break; case LOM_LED_STATE_ON_STEADY: buf += snprintf(buf, bufend - buf, ": ON"); break; case LOM_LED_STATE_ON_FLASHING: case LOM_LED_STATE_ON_SLOWFLASH: buf += snprintf(buf, bufend - buf, ": BLINKING"); break; case LOM_LED_STATE_INACCESSIBLE: buf += snprintf(buf, bufend - buf, ": inaccessible"); break; case LOM_LED_STATE_STANDBY: buf += snprintf(buf, bufend - buf, ": standby"); break; case LOM_LED_STATE_NOT_PRESENT: buf += snprintf(buf, bufend - buf, ": not present"); break; default: buf += snprintf(buf, bufend - buf, ": 0x%x", event->ev_resource); break; } break; case EVENT_SUBSYS_USER: switch (eventtype) { case EVENT_USER_ADDED: case EVENT_USER_REMOVED: case EVENT_USER_PERMSCHANGED: case EVENT_USER_LOGIN: case EVENT_USER_PASSWORD_CHANGE: case EVENT_USER_LOGINFAIL: case EVENT_USER_LOGOUT: buf += snprintf(buf, bufend - buf, " %d", event->ev_resource); default: break; } break; case EVENT_SUBSYS_PSU: if (event->ev_detail & LOM_PSU_NOACCESS) { buf += snprintf(buf, bufend - buf, " - inaccessible"); } else if ((event->ev_detail & LOM_PSU_STATUS_MASK) == LOM_PSU_STATUS_MASK) { buf += snprintf(buf, bufend - buf, " - OK"); } else { buf += snprintf(buf, bufend - buf, " -"); /* * If both inputs are seen to have failed then simply * indicate that the PSU input has failed */ if (!(event->ev_detail & (LOM_PSU_INPUT_A_OK | LOM_PSU_INPUT_B_OK))) { buf += snprintf(buf, bufend - buf, " Input"); } else { /* At least one input is ok */ if (!(event->ev_detail & LOM_PSU_INPUT_A_OK)) { buf += snprintf(buf, bufend - buf, " InA"); } if (!(event->ev_detail & LOM_PSU_INPUT_B_OK)) { buf += snprintf(buf, bufend - buf, " InB"); } /* * Only flag an output error if an input is * still present */ if (!(event->ev_detail & LOM_PSU_OUTPUT_OK)) { buf += snprintf(buf, bufend - buf, " Output"); } } buf += snprintf(buf, bufend - buf, " failed"); } break; case EVENT_SUBSYS_NONE: if (eventtype == EVENT_FAULT_LED) { switch (event->ev_detail) { case 0: buf += snprintf(buf, bufend - buf, " - ON"); break; case 255: buf += snprintf(buf, bufend - buf, " - OFF"); break; default: buf += snprintf(buf, bufend - buf, " - %dHz", event->ev_detail); break; } } break; case EVENT_SUBSYS_HOST: if (eventtype == EVENT_BOOTMODE_CHANGE) { switch (event->ev_detail & ~EBUS_BOOTMODE_FORCE_CONSOLE) { case EBUS_BOOTMODE_FORCE_NOBOOT: buf += snprintf(buf, bufend - buf, " - no boot"); break; case EBUS_BOOTMODE_RESET_DEFAULT: buf += snprintf(buf, bufend - buf, " - reset defaults"); break; case EBUS_BOOTMODE_FULLDIAG: buf += snprintf(buf, bufend - buf, " - full diag"); break; case EBUS_BOOTMODE_SKIPDIAG: buf += snprintf(buf, bufend - buf, " - skip diag"); break; default: break; } } if (eventtype == EVENT_SCC_STATUS) { switch (event->ev_detail) { case 0: buf += snprintf(buf, bufend - buf, " - inserted"); break; case 1: buf += snprintf(buf, bufend - buf, " - removed"); break; default: break; } } break; default: break; } /* shutd */ if (event->ev_subsys & EVENT_MASK_SHUTDOWN_REQD) { buf += snprintf(buf, bufend - buf, " - shutdown req'd"); } buf += snprintf(buf, bufend - buf, "\n"); if (buf >= bufend) { /* Ensure newline at end of string */ bufend[-2] = '\n'; bufend[-1] = '\0'; #ifdef DEBUG cmn_err(CE_WARN, "!bscv_build_eventstring: buffer too small!"); #endif /* DEBUG */ } } /* * function - bscv_level_of_event * description - This routine determines which level an event should be * reported at. * inputs - lom event structure pointer * outputs - event level. */ static int bscv_level_of_event(lom_event_t *event) { int level; /* * This is the same criteria that the firmware uses except we * log the fault led on as being EVENT_LEVEL_FAULT */ if (EVENT_DECODE_SUBSYS(event->ev_subsys) == EVENT_SUBSYS_USER) { level = EVENT_LEVEL_USER; } else if ((EVENT_DECODE_SUBSYS(event->ev_subsys) == EVENT_SUBSYS_ALARM) && (event->ev_event == EVENT_STATE_ON)) { level = EVENT_LEVEL_FAULT; } else if ((EVENT_DECODE_SUBSYS(event->ev_subsys) == EVENT_SUBSYS_NONE) && (event->ev_event == EVENT_FAULT_LED) && (event->ev_detail != 0xff)) { level = EVENT_LEVEL_FAULT; } else if ((EVENT_DECODE_SUBSYS(event->ev_subsys) == EVENT_SUBSYS_LOM) && event->ev_event == EVENT_TIME_REFERENCE) { level = EVENT_LEVEL_NOTICE; } else if (event->ev_event == EVENT_RECOVERED) { /* * All recovery messages need to be reported to the console * because during boot, the faults which occurred whilst * Solaris was not running are relayed to the console. There * is a case whereby a fatal fault (eg. over temp) could * have occurred and then recovered. The recovery condition * needs to be reported so the user doesn't think that the * failure (over temp) is still present. */ level = EVENT_LEVEL_FAULT; } else if (EVENT_DECODE_FAULT(event->ev_subsys) == 0) { /* None of FAULT, FATAL or SHUTDOWN REQD are set */ level = EVENT_LEVEL_NOTICE; } else if (EVENT_DECODE_FAULT(event->ev_subsys) == EVENT_MASK_FAULT) { /* Only FAULT set i.e not FATAL or SHUTDOWN REQD */ level = EVENT_LEVEL_FAULT; } else { level = EVENT_LEVEL_FATAL; } return (level); } /* * function - bscv_status * description - This routine is called when any change in the LOMlite2 status * is indicated by the status registers. * * inputs - LOM soft state structure pointer * * outputs - none. */ static void bscv_status(bscv_soft_state_t *ssp, uint8_t state_chng, uint8_t dev_no) { int8_t temp; uint8_t fanspeed; ASSERT(bscv_held(ssp)); bscv_trace(ssp, 'D', "bscv_status", "state_chng 0x%x dev_no 0x%x", state_chng, dev_no); /* * The device that has changed is given by the state change * register and the event detail register so react * accordingly. */ if (state_chng == EBUS_STATE_NOTIFY) { /* * The BSC is indicating a self state change */ if (dev_no == EBUS_DETAIL_FLASH) { ssp->cssp_prog = B_TRUE; bscv_trace(ssp, 'D', "bscv_status", "ssp->cssp_prog changed to 0x%x", ssp->cssp_prog); /* * It takes the BSC at least 100 ms to * clear down the comms protocol. * We back-off from talking to the * BSC during this period. */ delay(BSC_EVENT_POLL_NORMAL); bscv_trace(ssp, 'D', "bscv_status", "completed delay"); } else if (dev_no == EBUS_DETAIL_RESET) { /* * The bsc has reset */ bscv_trace(ssp, 'D', "bscv_status", "BSC reset occured, re-synching"); (void) bscv_attach_common(ssp); bscv_trace(ssp, 'D', "bscv_status", "completed attach_common"); } } if ((state_chng & EBUS_STATE_FAN) && ((dev_no - 1) < MAX_FANS)) { fanspeed = bscv_get8(ssp, chan_general, EBUS_IDX_FAN1_SPEED + dev_no - 1); /* * Only remember fanspeeds which are real values or * NOT PRESENT values. */ if ((fanspeed <= LOM_FAN_MAX_SPEED) || (fanspeed == LOM_FAN_NOT_PRESENT)) { ssp->fanspeed[dev_no - 1] = fanspeed; } } if ((state_chng & EBUS_STATE_PSU) && ((dev_no - 1) < MAX_PSUS)) { (void) bscv_get8(ssp, chan_general, EBUS_IDX_PSU1_STAT + dev_no - 1); } if (state_chng & EBUS_STATE_GP) { (void) bscv_get8(ssp, chan_general, EBUS_IDX_GPIP); } if (state_chng & EBUS_STATE_CB) { (void) bscv_get8(ssp, chan_general, EBUS_IDX_CBREAK_STATUS); } if ((state_chng & EBUS_STATE_TEMPERATURE) && ((dev_no - 1) < MAX_TEMPS)) { temp = bscv_get8(ssp, chan_general, EBUS_IDX_TEMP1 + dev_no - 1); /* * Only remember temperatures which are real values or * a NOT PRESENT value. */ if ((temp <= LOM_TEMP_MAX_VALUE) || (temp == LOM_TEMP_STATE_NOT_PRESENT)) { ssp->temps.temp[dev_no - 1] = temp; } } if (state_chng & EBUS_STATE_RAIL) { (void) bscv_get8(ssp, chan_general, EBUS_IDX_SUPPLY_LO); (void) bscv_get8(ssp, chan_general, EBUS_IDX_SUPPLY_HI); } } char * bscv_get_label(char labels[][MAX_LOM2_NAME_STR], int limit, int index) { if (labels == NULL) return (""); if (limit < 0 || index < 0 || index > limit) return ("-"); return (labels[index]); } static void bscv_generic_sysevent(bscv_soft_state_t *ssp, char *class, char *subclass, char *fru_id, char *res_id, int32_t fru_state, char *msg) { int rv; nvlist_t *attr_list; bscv_trace(ssp, 'E', "bscv_generic_sysevent", "%s/%s:(%s,%s,%d) %s", class, subclass, fru_id, res_id, fru_state, msg); if (nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, KM_SLEEP)) { bscv_trace(ssp, 'E', "bscv_generic_sysevent", "nvlist alloc failure"); return; } if (nvlist_add_uint32(attr_list, ENV_VERSION, 1)) { bscv_trace(ssp, 'E', "bscv_generic_sysevent", "nvlist ENV_VERSION failure"); nvlist_free(attr_list); return; } if (nvlist_add_string(attr_list, ENV_FRU_ID, fru_id)) { bscv_trace(ssp, 'E', "bscv_generic_sysevent", "nvlist ENV_FRU_ID failure"); nvlist_free(attr_list); return; } if (nvlist_add_string(attr_list, ENV_FRU_RESOURCE_ID, res_id)) { bscv_trace(ssp, 'E', "bscv_generic_sysevent", "nvlist ENV_FRU_RESOURCE_ID failure"); nvlist_free(attr_list); return; } if (nvlist_add_string(attr_list, ENV_FRU_DEVICE, ENV_RESERVED_ATTR)) { bscv_trace(ssp, 'E', "bscv_generic_sysevent", "nvlist ENV_FRU_DEVICE failure"); nvlist_free(attr_list); return; } if (nvlist_add_int32(attr_list, ENV_FRU_STATE, fru_state)) { bscv_trace(ssp, 'E', "bscv_generic_sysevent", "nvlist ENV_FRU_STATE failure"); nvlist_free(attr_list); return; } if (nvlist_add_string(attr_list, ENV_MSG, msg)) { bscv_trace(ssp, 'E', "bscv_generic_sysevent", "nvlist ENV_MSG failure"); nvlist_free(attr_list); return; } rv = ddi_log_sysevent(ssp->dip, DDI_VENDOR_SUNW, class, subclass, attr_list, NULL, DDI_SLEEP); if (rv == DDI_SUCCESS) { bscv_trace(ssp, 'E', "bscv_generic_sysevent", "sent sysevent"); } else { cmn_err(CE_WARN, "!cannot deliver sysevent"); } nvlist_free(attr_list); } /* * function - bscv_sysevent * description - send out a sysevent on the given change if needed * inputs - soft state pointer, event to report * outputs - none */ static void bscv_sysevent(bscv_soft_state_t *ssp, lom_event_t *event) { char *class = NULL; char *subclass = NULL; char *fru_id = "Blade"; /* The blade is only one FRU */ char *res_id; int32_t fru_state = 0; bscv_trace(ssp, 'E', "bscv_sysevent", "processing event"); ASSERT(event != NULL); /* Map ev_subsys to sysevent class/sub-class */ switch (EVENT_DECODE_SUBSYS(event->ev_subsys)) { case EVENT_SUBSYS_NONE: break; case EVENT_SUBSYS_ALARM: break; case EVENT_SUBSYS_TEMP: class = EC_ENV, subclass = ESC_ENV_TEMP; res_id = bscv_get_label(ssp->temps.name, ssp->temps.num, event->ev_resource - 1); switch (event->ev_event) { case EVENT_SEVERE_OVERHEAT: fru_state = ENV_FAILED; break; case EVENT_OVERHEAT: fru_state = ENV_WARNING; break; case EVENT_NO_OVERHEAT: fru_state = ENV_OK; break; default: return; } break; case EVENT_SUBSYS_OVERTEMP: break; case EVENT_SUBSYS_FAN: class = EC_ENV, subclass = ESC_ENV_FAN; res_id = bscv_get_label(ssp->fan_names, ssp->num_fans, event->ev_resource - 1); switch (event->ev_event) { case EVENT_FAILED: fru_state = ENV_FAILED; break; case EVENT_RECOVERED: fru_state = ENV_OK; break; default: return; } break; case EVENT_SUBSYS_SUPPLY: class = EC_ENV, subclass = ESC_ENV_POWER; res_id = bscv_get_label(ssp->sflags.name, ssp->sflags.num, event->ev_resource - 1); switch (event->ev_event) { case EVENT_FAILED: fru_state = ENV_FAILED; break; case EVENT_RECOVERED: fru_state = ENV_OK; break; default: return; } break; case EVENT_SUBSYS_BREAKER: break; case EVENT_SUBSYS_PSU: break; case EVENT_SUBSYS_USER: break; case EVENT_SUBSYS_PHONEHOME: break; case EVENT_SUBSYS_LOM: break; case EVENT_SUBSYS_HOST: break; case EVENT_SUBSYS_EVENTLOG: break; case EVENT_SUBSYS_EXTRA: break; case EVENT_SUBSYS_LED: if (event->ev_event != EVENT_FAULT_LED && event->ev_event != EVENT_STATE_CHANGE) return; /* * There are 3 LEDs : Power, Service, Ready-to-Remove on a * JBOS blade. We'll never report the Power since Solaris * won't be running when it is _switched_ ON. Ready-to-Remove * will only be lit when we're powered down which also means * Solaris won't be running. We don't want to report it * during system testing / Sun VTS exercising the LEDs. * * Therefore, we only report the Service Required LED. */ class = EC_ENV, subclass = ESC_ENV_LED; res_id = bscv_get_label(ssp->led_names, MAX_LED_ID, event->ev_resource - 1); switch (event->ev_detail) { case LOM_LED_STATE_ON_STEADY: fru_state = ENV_LED_ON; break; case LOM_LED_STATE_ON_FLASHING: case LOM_LED_STATE_ON_SLOWFLASH: fru_state = ENV_LED_BLINKING; break; case LOM_LED_STATE_OFF: fru_state = ENV_LED_OFF; break; case LOM_LED_STATE_INACCESSIBLE: fru_state = ENV_LED_INACCESSIBLE; break; case LOM_LED_STATE_STANDBY: fru_state = ENV_LED_STANDBY; break; case LOM_LED_STATE_NOT_PRESENT: fru_state = ENV_LED_NOT_PRESENT; break; default: fru_state = ENV_LED_INACCESSIBLE; break; } break; default : break; } if (class == NULL || subclass == NULL) { bscv_trace(ssp, 'E', "bscv_sysevent", "class/subclass NULL"); return; } bscv_generic_sysevent(ssp, class, subclass, fru_id, res_id, fru_state, ENV_RESERVED_ATTR); } /* * ********************************************************************* * Firmware download (programming) * ********************************************************************* */ /* * function - bscv_prog * description - LOMlite2 flash programming code. * * bscv_prog_image - download a complete image to the lom. * bscv_prog_receive_image - receive data to build up a * complete image. * bscv_prog_stop_lom - pause the event daemon and prepare * lom for firmware upgrade. * bscv_prog_start_lom - reinit the driver/lom after upgrade * and restart the event daemon * * inputs - soft state pointer, arg ptr, ioctl mode * outputs - status */ static int bscv_prog(bscv_soft_state_t *ssp, intptr_t arg, int mode) { lom_prog_t *prog; int res = 0; /* * We will get repeatedly called with bits of data first for * loader, then for main image. */ prog = (lom_prog_t *)kmem_alloc(sizeof (lom_prog_t), KM_SLEEP); if (ddi_copyin((caddr_t)arg, (caddr_t)prog, sizeof (*prog), mode) < 0) { kmem_free((void *)prog, sizeof (*prog)); return (EFAULT); } bscv_trace(ssp, 'U', "bscv_prog", "index 0x%x size 0x%x", prog->index, prog->size); mutex_enter(&ssp->prog_mu); if (prog->size == 0) { if (prog->index == 2) { /* * This is the initial request for the chip type so we * know what we are programming. * The type will have been read in at init so just * return it in data[0]. */ prog->data[0] = bscv_get8_cached(ssp, EBUS_IDX_CPU_IDENT); if (ddi_copyout((caddr_t)prog, (caddr_t)arg, sizeof (lom_prog_t), mode) < 0) { res = EFAULT; } } else if (prog->index == 0) { res = bscv_prog_stop_lom(ssp); } else if (prog->index == 1) { res = bscv_prog_start_lom(ssp); } else { res = EINVAL; } } else { if (ssp->image == NULL) { ssp->image = (uint8_t *)kmem_zalloc( BSC_IMAGE_MAX_SIZE, KM_SLEEP); } res = bscv_prog_receive_image(ssp, prog, ssp->image, BSC_IMAGE_MAX_SIZE); } mutex_exit(&ssp->prog_mu); kmem_free((void *)prog, sizeof (lom_prog_t)); return (res); } static int bscv_check_loader_config(bscv_soft_state_t *ssp, boolean_t is_image2) { bscv_trace(ssp, 'U', "bscv_check_loader_config", "loader_running %d, is_image2 %d", ssp->loader_running, is_image2); /* * loader_running TRUE means that we have told the microcontroller to * JUMP into the loader code which has been downloaded into its RAM. * At this point its an error to try and download another loader. We * should be downloading the actual image at this point. * Conversely, it is an error to download an image when the loader is * not already downloaded and the microcontroller hasn't JUMPed into it. * is_image2 TRUE means the image is being downloaded. * is_image2 FALSE means the loader is being downloaded. */ if (ssp->loader_running && !is_image2) { cmn_err(CE_WARN, "Attempt to download loader image " "with loader image already active"); cmn_err(CE_CONT, "This maybe an attempt to restart a " "failed firmware download - ignoring download attempt"); return (B_FALSE); } else if (!ssp->loader_running && is_image2) { cmn_err(CE_WARN, "Attempt to download firmware image " "without loader image active"); return (B_FALSE); } return (B_TRUE); } static uint32_t bscv_get_pagesize(bscv_soft_state_t *ssp) { uint32_t pagesize; ASSERT(bscv_held(ssp)); pagesize = bscv_get32(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PAGE0)); bscv_trace(ssp, 'U', "bscv_get_pagesize", "pagesize 0x%x", pagesize); return (pagesize); } /* * Sets the pagesize, returning the old value. */ static uint32_t bscv_set_pagesize(bscv_soft_state_t *ssp, uint32_t pagesize) { uint32_t old_pagesize; ASSERT(bscv_held(ssp)); old_pagesize = bscv_get_pagesize(ssp); /* * The microcontroller remembers this value until until someone * changes it. */ bscv_put32(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PSIZ0), pagesize); return (old_pagesize); } static uint8_t bscv_enter_programming_mode(bscv_soft_state_t *ssp) { uint8_t retval; ASSERT(bscv_held(ssp)); bscv_put8(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR), EBUS_PROGRAM_PCR_PRGMODE_ON); retval = bscv_get8(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR)); return (retval); } static void bscv_leave_programming_mode(bscv_soft_state_t *ssp, boolean_t with_jmp) { uint8_t reg; ASSERT(bscv_held(ssp)); if (with_jmp) { reg = EBUS_PROGRAM_PCR_PROGOFF_JUMPTOADDR; bscv_trace(ssp, 'U', "bscv_leave_programming_mode", "jumptoaddr"); } else { reg = EBUS_PROGRAM_PCR_PRGMODE_OFF; bscv_trace(ssp, 'U', "bscv_leave_programming_mode", "prgmode_off"); } bscv_put8(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR), reg); } static void bscv_set_jump_to_addr(bscv_soft_state_t *ssp, uint32_t loadaddr) { ASSERT(bscv_held(ssp)); bscv_put32(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PADR0), loadaddr); bscv_trace(ssp, 'U', "bscv_set_jump_to_addr", "set jump to loadaddr 0x%x", loadaddr); } static uint8_t bscv_erase_once(bscv_soft_state_t *ssp, uint32_t loadaddr, uint32_t image_size) { uint8_t retval; ASSERT(bscv_held(ssp)); /* * write PADR, PSIZ to define area to be erased * We do not send erase for zero size because the current * downloader gets this wrong */ /* * start at 0 */ bscv_trace(ssp, 'U', "bscv_erase_once", "sending erase command"); bscv_put32(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PADR0), loadaddr); /* set PSIZ to full size of image to be programmed */ bscv_put32(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PSIZ0), image_size); /* write ERASE to PCSR */ bscv_put8(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR), EBUS_PROGRAM_PCR_ERASE); /* read PCSR to check status */ retval = bscv_get8(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR)); return (retval); } static uint8_t bscv_do_erase(bscv_soft_state_t *ssp, uint32_t loadaddr, uint32_t image_size, boolean_t is_image2) { int retryable = BSC_ERASE_RETRY_LIMIT; uint8_t retval; while (retryable--) { retval = bscv_erase_once(ssp, loadaddr, image_size); if (PSR_SUCCESS(retval)) break; else cmn_err(CE_WARN, "erase error 0x%x, attempt %d" ", base 0x%x, size 0x%x, %s image", retval, BSC_ERASE_RETRY_LIMIT - retryable, loadaddr, image_size, is_image2 ? "main" : "loader"); } return (retval); } static uint8_t bscv_set_page(bscv_soft_state_t *ssp, uint32_t addr) { uint32_t retval; int retryable = BSC_PAGE_RETRY_LIMIT; ASSERT(bscv_held(ssp)); while (retryable--) { /* * Write the page address and read it back for confirmation. */ bscv_put32(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PADR0), addr); retval = bscv_get32(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PADR0)); if (retval == addr) break; else { cmn_err(CE_WARN, "programmming error, attempt %d, " "set page 0x%x, read back 0x%x", BSC_PAGE_RETRY_LIMIT - retryable, addr, retval); } } return ((addr == retval) ? EBUS_PROGRAM_PSR_SUCCESS : EBUS_PROGRAM_PSR_INVALID_OPERATION); } static uint8_t bscv_do_page_data_once(bscv_soft_state_t *ssp, uint32_t index, uint32_t image_size, uint32_t pagesize, uint8_t *imagep, uint16_t *calcd_chksum) { uint32_t size; uint16_t chksum; int i; uint8_t retval; ASSERT(bscv_held(ssp)); bscv_trace(ssp, 'P', "bscv_do_page_data_once", "index 0x%x", index); /* write PSIZ bytes to PDAT */ if (index + pagesize < image_size) { bscv_rep_rw8(ssp, chan_prog, imagep + index, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_DATA), pagesize, DDI_DEV_NO_AUTOINCR, B_TRUE /* write */); size = pagesize; } else { bscv_trace(ssp, 'P', "bscv_do_page_once", "Sending last block, last 0x%x bytes", (image_size % pagesize)); size = (image_size - index); bscv_rep_rw8(ssp, chan_prog, imagep + index, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_DATA), size, DDI_DEV_NO_AUTOINCR, B_TRUE /* write */); /* Now pad the rest of the page with zeros */ for (i = size; i < pagesize; i++) { bscv_put8(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_DATA), 0); } } /* write the checksum to PCSM */ chksum = 0; for (i = 0; i < size; i++) { chksum = ((chksum << 3) | (chksum >> 13)) ^ *(imagep + index + i); } /* Cope with non-pagesize sized bufers */ for (; i < pagesize; i++) { chksum = ((chksum << 3) | (chksum >> 13)) ^ 0; } bscv_put16(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSM0), chksum); bscv_put8(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR), EBUS_PROGRAM_PCR_PROGRAM); retval = bscv_get8(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR)); *calcd_chksum = chksum; return (retval); } static uint8_t bscv_do_page(bscv_soft_state_t *ssp, uint32_t loadaddr, uint32_t index, uint32_t image_size, uint32_t pagesize, uint8_t *imagep, boolean_t is_image2) { int retryable = BSC_PAGE_RETRY_LIMIT; uint8_t retval; uint16_t checksum; bscv_trace(ssp, 'P', "bscv_do_page", "index 0x%x", index); while (retryable--) { /* * Set the page address (with retries). If this is not * successful, then there is no point carrying on and sending * the page's data since that could cause random memory * corruption in the microcontroller. */ retval = bscv_set_page(ssp, loadaddr + index); if (!PSR_SUCCESS(retval)) { cmn_err(CE_WARN, "programming error 0x%x, " "could not setup page address 0x%x, %s image", retval, loadaddr + index, is_image2 ? "main" : "loader"); break; } /* * Send down the data for the page */ bscv_trace(ssp, 'P', "bscv_do_page", "sending data for page"); retval = bscv_do_page_data_once(ssp, index, image_size, pagesize, imagep, &checksum); if (PSR_SUCCESS(retval)) break; else cmn_err(CE_WARN, "programming error 0x%x," " attempt %d, index 0x%x, checksum 0x%x, %s image", retval, BSC_PAGE_RETRY_LIMIT - retryable, index, checksum, is_image2 ? "main" : "loader"); } bscv_trace(ssp, 'U', "bscv_do_page", "Returning 0x%x for index 0x%x," " checksum 0x%x, %s image", retval, index, checksum, is_image2 ? "main" : "loader"); return (retval); } static uint8_t bscv_do_pages(bscv_soft_state_t *ssp, uint32_t loadaddr, uint32_t image_size, uint32_t pagesize, uint8_t *imagep, boolean_t is_image2) { uint8_t retval; uint32_t index; bscv_trace(ssp, 'P', "bscv_do_pages", "entered"); for (index = 0; index < image_size; index += pagesize) { retval = bscv_do_page(ssp, loadaddr, index, image_size, pagesize, imagep, is_image2); if (bscv_faulty(ssp) || !PSR_SUCCESS(retval)) { bscv_trace(ssp, 'U', "bscv_do_pages", "Failed to program lom (status 0x%x)", retval); break; } } return (retval); } static int bscv_prog_image(bscv_soft_state_t *ssp, boolean_t is_image2, uint8_t *imagep, int image_size, uint32_t loadaddr) { uint32_t pagesize; int res = 0; uint8_t retval; bscv_trace(ssp, 'U', "bscv_prog_image", "image 0x%x, imagep %p, size 0x%x", is_image2 ? 2 : 1, imagep, image_size); if (!bscv_check_loader_config(ssp, is_image2)) /* * Return no error to allow userland to continue on with * downloading the image. */ return (0); bscv_enter(ssp); pagesize = bscv_get_pagesize(ssp); retval = bscv_enter_programming_mode(ssp); if (bscv_faulty(ssp) || !PSR_PROG(retval)) { cmn_err(CE_WARN, "lom: Failed to enter program mode, error 0x%x" ", %s image", retval, is_image2 ? "main" : "loader"); res = EIO; goto BSCV_PROG_IMAGE_END; } bscv_trace(ssp, 'U', "bscv_prog_image", "entered programming mode"); /* * Only issue an erase if we are downloading the image. The loader * does not need this step. */ if (is_image2 && (image_size != 0)) { retval = bscv_do_erase(ssp, loadaddr, image_size, is_image2); if (bscv_faulty(ssp) || !PSR_SUCCESS(retval)) { cmn_err(CE_WARN, "lom: Erase failed during programming, status 0x%x", retval); res = EIO; goto BSCV_PROG_IMAGE_END; } else { bscv_trace(ssp, 'U', "bscv_prog_image", "erase complete - programming..."); } } (void) bscv_set_pagesize(ssp, pagesize); retval = bscv_do_pages(ssp, loadaddr, image_size, pagesize, imagep, is_image2); if (bscv_faulty(ssp) || !PSR_SUCCESS(retval)) { bscv_trace(ssp, 'U', "bscv_prog_image", "Failed to program lom (status 0x%x)", retval); res = EIO; goto BSCV_PROG_IMAGE_END; } BSCV_PROG_IMAGE_END: if (res == 0 && !is_image2) { /* * We've downloaded the loader successfully. Now make the * microcontroller jump to it. */ bscv_set_jump_to_addr(ssp, loadaddr); ssp->loader_running = B_TRUE; bscv_leave_programming_mode(ssp, B_TRUE); } else { /* * We've just downloaded either the loader which failed, or * the image (which may or may not have been successful). */ bscv_set_jump_to_addr(ssp, 0); if (res != 0) { bscv_trace(ssp, 'U', "bscv_prog_image", "got error 0x%x - leaving programming mode", res); cmn_err(CE_WARN, "programming error 0x%x, %s image", res, is_image2 ? "main" : "loader"); } else { bscv_trace(ssp, 'U', "bscv_prog_image", "programming complete - leaving programming mode"); } bscv_leave_programming_mode(ssp, B_FALSE); ssp->loader_running = B_FALSE; } bscv_exit(ssp); return (res); } static int bscv_prog_receive_image(bscv_soft_state_t *ssp, lom_prog_t *prog, uint8_t *imagep, int max_size) { int res = 0; uint_t size; int32_t loadaddr; lom_prog_data_t *prog_data; if ((prog->index & 0x7FFF) != ssp->prog_index) { bscv_trace(ssp, 'U', "bscv_prog_receive_image", "Got wrong buffer 0x%x, expected 0x%x", prog->index & 0x7fff, ssp->prog_index); return (EINVAL); } /* * We want to get the whole image and then do the download. * It is assumed the device is now in programming mode. */ if ((prog->index & 0x7fff) == 0) { /* Starting a new image */ ssp->image_ptr = 0; } if ((ssp->image_ptr + prog->size) > max_size) { cmn_err(CE_WARN, "lom image exceeded maximum size: got 0x%x, maximum 0x%x", (ssp->image_ptr + prog->size), max_size); return (EFAULT); } bcopy(prog->data, &imagep[ssp->image_ptr], prog->size); ssp->image_ptr += prog->size; ssp->prog_index++; if (prog->index & 0x8000) { /* * OK we have the whole image so synch up and start download. */ prog_data = (lom_prog_data_t *)imagep; if (prog_data->header.magic != PROG_MAGIC) { /* Old style programming data */ /* Take care image may not fill all of structure */ /* sign extend loadaddr from 16 to 32 bits */ loadaddr = (int16_t)((uint16_t)((imagep[2] << 8) + imagep[3])); size = (imagep[0] << 8) + imagep[1]; if (size != (ssp->image_ptr - 4)) { cmn_err(CE_WARN, "Image size mismatch:" " expected 0x%x, got 0x%x", size, (ssp->image_ptr - 1)); } res = bscv_prog_image(ssp, ssp->image2_processing, imagep + 4, ssp->image_ptr - 4, loadaddr); /* * Done the loading so set the flag to say we are doing * the other image. */ ssp->image2_processing = !ssp->image2_processing; } else if ((ssp->image_ptr < sizeof (*prog_data)) || (prog_data->platform.bscv.size != (ssp->image_ptr - sizeof (*prog_data)))) { /* Image too small for new style image */ cmn_err(CE_WARN, "image too small"); res = EINVAL; } else { /* New style programming image */ switch (prog_data->platmagic) { case PROG_PLAT_BSCV_IMAGE: res = bscv_prog_image(ssp, B_TRUE, imagep + sizeof (*prog_data), prog_data->platform.bscv.size, prog_data->platform.bscv.loadaddr); ssp->image2_processing = B_FALSE; break; case PROG_PLAT_BSCV_LOADER: res = bscv_prog_image(ssp, B_FALSE, imagep + sizeof (*prog_data), prog_data->platform.bscv.size, prog_data->platform.bscv.loadaddr); ssp->image2_processing = B_TRUE; break; default: cmn_err(CE_WARN, "unknown platmagic 0x%x", prog_data->platmagic); res = EINVAL; break; } } ssp->prog_index = 0; ssp->image_ptr = 0; } return (res); } static int bscv_prog_stop_lom(bscv_soft_state_t *ssp) { if (ssp->programming) { /* * Already programming - this may be a retry of a failed * programming attempt or just a software error! */ goto queue_stopped; } if (bscv_pause_event_daemon(ssp) == BSCV_FAILURE) { bscv_trace(ssp, 'Q', "bscv_prog_stop_lom", "failed to pause event daemon thread"); return (EAGAIN); } bscv_enter(ssp); ssp->programming = B_TRUE; bscv_exit(ssp); queue_stopped: ssp->prog_index = 0; ssp->image2_processing = B_FALSE; return (0); } static int bscv_prog_start_lom(bscv_soft_state_t *ssp) { int res = 0; if (!ssp->programming) { /* Not programming so this is not a valid command */ return (EINVAL); } if (ssp->image != NULL) { kmem_free((void *)ssp->image, BSC_IMAGE_MAX_SIZE); ssp->image = NULL; } /* * OK we are out of reset now so: * Probe the firmware and set everything up. */ bscv_enter(ssp); /* Explicit clear fault because things may have been mended now */ bscv_clear_fault(ssp); if (ssp->loader_running) { cmn_err(CE_WARN, "Firmware upgrade failed to exit loader - " "performing forced exit"); /* Must try to restart the lom here. */ /* Ensure prog mode entry to enable PRGMODE_OFF */ bscv_put8(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR), EBUS_PROGRAM_PCR_PRGMODE_ON); bscv_put8(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR), EBUS_PROGRAM_PCR_PRGMODE_OFF); ssp->loader_running = B_FALSE; /* give the lom chance to recover */ delay(drv_usectohz(5000000)); /* 5 seconds */ } ssp->prog_mode_only = B_FALSE; ssp->programming = B_FALSE; if (bscv_attach_common(ssp) == DDI_FAILURE) { ssp->prog_mode_only = B_TRUE; res = EIO; } bscv_exit(ssp); if (!ssp->prog_mode_only) { /* * Start the event thread after the queue has started * * Not sure if this is entirely correct because * the other code at the end of bscv_attach() * does not get run here. */ bscv_start_event_daemon(ssp); bscv_resume_event_daemon(ssp); } return (res); } /* * ********************************************************************* * Attach processing * ********************************************************************* */ /* * function - bscv_attach_common * description - this routine co-ordinates the initialisation of the * driver both at attach time and after firmware programming. * sequence - bscv_setup_capability - read LOMlite2 capabilities * bscv_probe_check - test comms and setup register cache * bscv_setup_hostname - sync stored name in lom with nodename. * bscv_setup_static_info - read device names etc. * bscv_setup_events - start event daemon etc. * * inputs - device information structure, DDI_ATTACH command * outputs - DDI_SUCCESS or DDI_FAILURE */ static int bscv_attach_common(bscv_soft_state_t *ssp) { ASSERT(bscv_held(ssp)); bscv_trace(ssp, 'A', "bscv_attach_common:", ""); /* * Set the threshold for reporting messages to the console to * Warnings or higher. */ ssp->reporting_level = 2; /* * When the system is not running the Operating System, make * the microcontroller print event messages straight onto the * console. */ ssp->serial_reporting = LOM_SER_EVENTS_DEF; /* Setup capabilities */ bscv_setup_capability(ssp); if (bscv_probe_check(ssp) == DDI_FAILURE) { cmn_err(CE_WARN, "BSC chip not responding"); /* * We want lom -G to talk to this driver upon broken firmware * so we prematurely return success here. */ return (DDI_SUCCESS); } bscv_setup_hostname(ssp); bscv_setup_static_info(ssp); bscv_setup_events(ssp); #if defined(__i386) || defined(__amd64) bscv_inform_bsc(ssp, BSC_INFORM_ONLINE); #endif /* __i386 || __amd64 */ /* * Watchdog configuration and CPU signatures are sent asynchronously * with respect to attach so only inform the BSC if we've already * sent the data in the past. */ if (ssp->progress & BSCV_WDOG_CFG) bscv_setup_watchdog(ssp); #ifdef __sparc if (ssp->progress & BSCV_SIG_SENT) bscv_write_sig(ssp, ssp->last_sig); #endif /* __sparc */ return (DDI_SUCCESS); } /* * function - bscv_cleanup * description - routine that does the necessary tidying up if the attach * request fails or the driver is to be detached. * If the event thread has been started we may fail to * stop it (because it is busy) so we fail the cleanup * and hence the detach. All other calls to bscv_cleanup * are done before the event daemon is started. * inputs - soft state structure address. * outputs - DDI_SUCCESS or DDI_FAILURE. */ static int bscv_cleanup(bscv_soft_state_t *ssp) { int instance; uint8_t bits2set; uint8_t bits2clear; instance = ssp->instance; if (ssp->progress & BSCV_LOCKS) { bscv_enter(ssp); } if (ssp->progress & BSCV_THREAD) { if (bscv_stop_event_daemon(ssp) == DDI_FAILURE) { /* Fail the cleanup - may be able to cleanup later */ if (ssp->progress & BSCV_LOCKS) { bscv_exit(ssp); } return (DDI_FAILURE); } } if (ssp->progress & BSCV_NODES) { ddi_remove_minor_node(ssp->dip, NULL); } if (ssp->progress & BSCV_MAPPED_REGS) { /* * switch back on serial event reporting - cover all configs. */ bits2set = 0; bits2clear = 0; if (ssp->serial_reporting == LOM_SER_EVENTS_ON) { bits2clear |= EBUS_ALARM_NOEVENTS; } else if (ssp->serial_reporting == LOM_SER_EVENTS_OFF) { bits2set |= EBUS_ALARM_NOEVENTS; } else if (ssp->serial_reporting == LOM_SER_EVENTS_DEF) { bits2clear |= EBUS_ALARM_NOEVENTS; } bscv_setclear8_volatile(ssp, chan_general, EBUS_IDX_ALARM, bits2set, bits2clear); /* * disable the reset function if we have enabled * it. We don't want any nasty surprises like system * rebooting unexpectedly. If we timeout on the busy * flag we just have to carry on. */ bscv_trace(ssp, 'W', "bscv_cleanup", "bscv_cleanup - disable wdog"); if (bscv_get8_cached(ssp, EBUS_IDX_WDOG_CTRL) & EBUS_WDOG_ENABLE) { bscv_setclear8(ssp, chan_general, EBUS_IDX_WDOG_CTRL, 0, EBUS_WDOG_RST | EBUS_WDOG_ENABLE); } } /* * unmap registers */ if (ssp->progress & BSCV_MAPPED_REGS) { bscv_unmap_regs(ssp); } /* * release any memory allocated for mutexes and condition * variables before deallocating the structures containing them */ if (ssp->progress & BSCV_LOCKS) { bscv_exit(ssp); cv_destroy(&ssp->task_cv); cv_destroy(&ssp->task_evnt_cv); mutex_destroy(&ssp->task_mu); mutex_destroy(&ssp->prog_mu); mutex_destroy(&ssp->cmd_mutex); } if (ssp->image != NULL) { kmem_free((void *)ssp->image, BSC_IMAGE_MAX_SIZE); } #if defined(__i386) || defined(__amd64) mutex_enter(&cpu_lock); bscv_watchdog_cyclic_remove(ssp); mutex_exit(&cpu_lock); #endif /* __i386 || __amd64 */ ddi_soft_state_free(bscv_statep, instance); return (DDI_SUCCESS); } /* * function - bscv_setup_capability * description - probe the lom find what capabilities are present for * us to use. * inputs - soft state ptr * outputs - returns DDI_SUCCESS or DDI_FAILURE */ static void bscv_setup_capability(bscv_soft_state_t *ssp) { ASSERT(bscv_held(ssp)); if (ssp->prog_mode_only) { /* Turn off all capabilities */ ssp->cap0 = 0; ssp->cap1 = 0; ssp->cap2 = 0; return; } ssp->cap0 = bscv_get8(ssp, chan_general, EBUS_IDX_CAP0); ssp->cap1 = bscv_get8(ssp, chan_general, EBUS_IDX_CAP1); ssp->cap2 = bscv_get8(ssp, chan_general, EBUS_IDX_CAP2); if (!bscv_faulty(ssp)) { bscv_trace(ssp, 'A', "bscv_setup_capability", "Capability flags cap0=0x%x cap1=0x%x, cap2=0x%x", ssp->cap0, ssp->cap1, ssp->cap2); } else { cmn_err(CE_WARN, "!Could not read capability flags"); ssp->cap0 = 0; ssp->cap1 = 0; ssp->cap2 = 0; } } /* * function - bscv_probe_check * description - probe the lom to check for correct operation * has a side effect of setting up the cached registers and * updates ssp->prog_mode_only. * inputs - soft state ptr * outputs - returns DDI_SUCCESS or DDI_FAILURE */ static int bscv_probe_check(bscv_soft_state_t *ssp) { int i; uint8_t probeval; ASSERT(bscv_held(ssp)); bscv_trace(ssp, 'A', "bscv_probe_check", ""); if (!ssp->prog_mode_only) { /* * Make sure probe location is OK so that we are * in sync. * We want to make sure that this is not faulty so we * do a bscv_clear_fault to clear any existing * fault records down. */ bscv_clear_fault(ssp); probeval = bscv_get8(ssp, chan_general, EBUS_IDX_PROBEAA); if (bscv_faulty(ssp)) { ssp->prog_mode_only = B_TRUE; } else if (probeval != 0xAA) { bscv_trace(ssp, 'A', "bscv_probe_check", "LOMlite out of sync"); /* * It may be that the LOMlite was out of * sync so lets try the read again. */ probeval = bscv_get8(ssp, chan_general, EBUS_IDX_PROBEAA); if (bscv_faulty(ssp)) { bscv_trace(ssp, 'A', "bscv_probe_check", "Init readAA1 failed"); ssp->prog_mode_only = B_TRUE; } else if (probeval != 0xAA) { /* * OK that is twice we are out so I * guess the LOMlite is in trouble */ bscv_trace(ssp, 'A', "bscv_probe_check", "Init readAA probe failed - got 0x%x", probeval); ssp->prog_mode_only = B_TRUE; } } } /* * Read in all page zero lom registers. * Read state change 1st so we dont miss anything and clear it. * Note: we discard the values because we rely on bscv_get8 to * setup the cache of register values. */ if (!ssp->prog_mode_only) { (void) bscv_get8(ssp, chan_general, EBUS_IDX_STATE_CHNG); if (bscv_faulty(ssp)) { bscv_trace(ssp, 'A', "bscv_probe_check", "Read of state change register failed"); ssp->prog_mode_only = B_TRUE; } } if (!ssp->prog_mode_only) { for (i = 1; i < 0x80; i++) { switch (i) { case EBUS_IDX_STATE_CHNG: case EBUS_IDX_CMD_RES: case EBUS_IDX_HNAME_CHAR: /* * Should not read these - they have side * effects. */ break; default: (void) bscv_get8(ssp, chan_general, i); break; } if (bscv_faulty(ssp)) { bscv_trace(ssp, 'A', "bscv_probe_check", "Initial read or register %2x failed", i); ssp->prog_mode_only = B_TRUE; /* Might as well give up now! */ break; } } } /* * Check the probe keys so we know the lom is OK */ if (!ssp->prog_mode_only) { if ((bscv_get8_cached(ssp, EBUS_IDX_PROBE55) != 0x55) || (bscv_get8_cached(ssp, EBUS_IDX_PROBEAA) != 0xAA)) { bscv_trace(ssp, 'A', "bscv_probe_check", "LOMlite Probe failed"); for (i = 0; i < 0x8; i++) { bscv_trace(ssp, 'A', "bscv_probe_check", "%2x %2x %2x %2x %2x %2x %2x %2x %2x " "%2x %2x %2x %2x %2x %2x %2x %2x %2x", bscv_get8_cached(ssp, i), bscv_get8_cached(ssp, i + 1), bscv_get8_cached(ssp, i + 2), bscv_get8_cached(ssp, i + 3), bscv_get8_cached(ssp, i + 4), bscv_get8_cached(ssp, i + 5), bscv_get8_cached(ssp, i + 6), bscv_get8_cached(ssp, i + 7), bscv_get8_cached(ssp, i + 8), bscv_get8_cached(ssp, i + 9), bscv_get8_cached(ssp, i + 10), bscv_get8_cached(ssp, i + 11), bscv_get8_cached(ssp, i + 12), bscv_get8_cached(ssp, i + 13), bscv_get8_cached(ssp, i + 14), bscv_get8_cached(ssp, i + 15)); } ssp->prog_mode_only = B_TRUE; } } return ((ssp->prog_mode_only == B_FALSE) ? DDI_SUCCESS : DDI_FAILURE); } #ifdef __sparc /* * function - bscv_idi_set * description - bscv inter driver interface set function * inputs - structure which defines type of service required and data * ouputs - none * * This is the Entry Point function for the platmod driver. It works out which * X Bus channel ought to deliver the service requested. */ void bscv_idi_set(struct bscv_idi_info info) { struct bscv_idi_callout *tbl; boolean_t retval; ASSERT(bscv_idi_mgr.magic == BSCV_IDI_CALLOUT_MAGIC); if (bscv_idi_mgr.tbl == NULL) { if (bscv_idi_err()) cmn_err(CE_WARN, "!bscv_idi_set : cannot find " "bscv_callout_table"); return; } else if (bscv_idi_mgr.valid_inst == (uint32_t)~0) { if (bscv_idi_err()) /* * This error message can appear in the context of * another driver, say platmod or todblade. We want * to clearly indicate the culprit driver so put in * the driver name. */ cmn_err(CE_WARN, "!bscv_idi_set : no valid " "driver instance of " MYNAME); return; } tbl = bscv_idi_mgr.tbl; while (tbl->type != BSCV_IDI_NULL) { if (tbl->type == info.type) { /* * We service the request with a valid instance number * for the driver. */ retval = ((tbl->fn) (info)); /* * If the request was serviced, clear any accumulated * error counters so future warnings will be reported if * seen. */ if (retval == B_TRUE) bscv_idi_clear_err(); return; } else { tbl++; } } if (bscv_idi_err()) cmn_err(CE_WARN, "!bscv_idi_set : cannot match info.type %d", info.type); } /* * function - bscv_nodename_set * description - notify the event thread that a nodename change has occurred. * inputs - data from client driver * outputs - none. * side-effects - the event thread will schedule an update to the lom firmware. */ /*ARGSUSED*/ static boolean_t bscv_nodename_set(struct bscv_idi_info info) { bscv_soft_state_t *ssp; ssp = ddi_get_soft_state(bscv_statep, bscv_idi_mgr.valid_inst); if (ssp == NULL) { if (bscv_idi_err()) cmn_err(CE_WARN, "!blade_nodename_set: cannot get ssp"); return (B_FALSE); } /* Get a lock on the SSP, notify our change, then exit */ mutex_enter(&ssp->task_mu); ssp->nodename_change = B_TRUE; cv_signal(&ssp->task_cv); mutex_exit(&ssp->task_mu); return (B_TRUE); } /* * function - bscv_sig_set * description - write a signature * inputs - data from client driver * outputs - none. */ static boolean_t bscv_sig_set(struct bscv_idi_info info) { bscv_soft_state_t *ssp; bscv_sig_t sig; ssp = ddi_get_soft_state(bscv_statep, bscv_idi_mgr.valid_inst); if (ssp == NULL) { if (bscv_idi_err()) cmn_err(CE_WARN, "!blade_nodename_set: cannot get ssp"); return (B_FALSE); } /* Service the request */ bcopy(info.data, &sig, sizeof (sig)); bscv_enter(ssp); bscv_write_sig(ssp, sig); bscv_exit(ssp); return (B_TRUE); } #endif /* __sparc */ static void bscv_wdog_do_pat(bscv_soft_state_t *ssp) { uint8_t pat; /* * The value of the dog pat is a sequence number which wraps around, * bounded by BSCV_WDOG_PAT_SEQ_MASK. */ pat = ssp->pat_seq++; pat &= EBUS_WDOG_NB_PAT_SEQ_MASK; /* Set top nibble to indicate a pat */ pat |= EBUS_WDOG_NB_PAT; /* * Now pat the dog. This exercises a special protocol in the * bus nexus that offers : non-blocking IO, and timely delivery, * callable from high-level interrupt context. The requirement * on us is that the channel is not shared for any other use. * This means for chan_wdogpat, nothing may use channel[chan].regs * or channel.[chan].handle. */ ddi_put8(ssp->channel[chan_wdogpat].handle, ssp->channel[chan_wdogpat].regs, pat); bscv_trace(ssp, 'W', "bscv_wdog_pat", "patted the dog with seq %d", pat); } #ifdef __sparc /* * function - bscv_wdog_pat * description - pat the watchdog * inputs - data from client driver * outputs - none. */ /*ARGSUSED*/ static boolean_t bscv_wdog_pat(struct bscv_idi_info info) { /* * This function remembers if it has ever been called with the * configure option set. */ bscv_soft_state_t *ssp; ssp = ddi_get_soft_state(bscv_statep, bscv_idi_mgr.valid_inst); if (ssp == NULL) { if (bscv_idi_err()) cmn_err(CE_WARN, "!bscv_wdog_pat: cannot get ssp"); return (B_FALSE); } else if (ssp->nchannels == 0) { /* Didn't manage to map handles so ddi_{get,put}* broken */ if (bscv_idi_err()) cmn_err(CE_WARN, "!bscv_wdog_pat: handle not mapped"); return (B_FALSE); } bscv_wdog_do_pat(ssp); return (B_TRUE); } /* * function - bscv_wdog_cfg * description - configure the watchdog * inputs - data from client driver * outputs - none. */ static boolean_t bscv_wdog_cfg(struct bscv_idi_info info) { bscv_soft_state_t *ssp; ssp = ddi_get_soft_state(bscv_statep, bscv_idi_mgr.valid_inst); if (ssp == NULL) { if (bscv_idi_err()) cmn_err(CE_WARN, "!bscv_wdog_cfg: cannot get ssp"); return (B_FALSE); } else if (ssp->nchannels == 0) { /* Didn't manage to map handles so ddi_{get,put}* broken */ if (bscv_idi_err()) cmn_err(CE_WARN, "!bscv_wdog_cfg: handle not mapped"); return (B_FALSE); } if (sizeof (bscv_wdog_t) != info.size) { bscv_trace(ssp, 'W', "bscv_wdog_set", "data passed in is size" " %d instead of %d", info.size, sizeof (bscv_wdog_t)); return (B_FALSE); } bscv_trace(ssp, 'W', "bscv_wdog_cfg", "enable_wdog %s, " "wdog_timeout_s %d, reset_system_on_timeout %s", ((bscv_wdog_t *)info.data)->enable_wdog ? "enabled" : "disabled", ((bscv_wdog_t *)info.data)->wdog_timeout_s, ((bscv_wdog_t *)info.data)->reset_system_on_timeout ? "yes" : "no"); bscv_write_wdog_cfg(ssp, ((bscv_wdog_t *)info.data)->wdog_timeout_s, ((bscv_wdog_t *)info.data)->enable_wdog, ((bscv_wdog_t *)info.data)->reset_system_on_timeout); return (B_TRUE); } #endif /* __sparc */ static void bscv_write_wdog_cfg(bscv_soft_state_t *ssp, uint_t wdog_timeout_s, boolean_t enable_wdog, uint8_t reset_system_on_timeout) { uint8_t cfg = EBUS_WDOG_NB_CFG; /* * Configure the timeout value (1 to 127 seconds). * Note that a policy is implemented at the bsc/ssp which bounds * the value further. The bounding here is to fit the timeout value * into the 7 bits the bsc uses. */ if (wdog_timeout_s < 1) ssp->watchdog_timeout = 1; else if (wdog_timeout_s > 127) ssp->watchdog_timeout = 127; else ssp->watchdog_timeout = wdog_timeout_s; /* * Configure the watchdog on or off. */ if (enable_wdog) cfg |= EBUS_WDOG_NB_CFG_ENB; else cfg &= ~EBUS_WDOG_NB_CFG_ENB; /* * Configure whether the microcontroller should reset the system when * the watchdog expires. */ ssp->watchdog_reset_on_timeout = reset_system_on_timeout; ddi_put8(ssp->channel[chan_wdogpat].handle, ssp->channel[chan_wdogpat].regs, cfg); /* have the event daemon set the timeout value and whether to reset */ ssp->watchdog_change = B_TRUE; bscv_trace(ssp, 'W', "bscv_wdog_cfg", "configured the dog with cfg 0x%x", cfg); } /* * function - bscv_setup_watchdog * description - setup the bsc watchdog * inputs - soft state ptr * outputs - */ static void bscv_setup_watchdog(bscv_soft_state_t *ssp) { uint8_t set = 0; uint8_t clear = 0; #ifdef __sparc extern int watchdog_activated; #endif /* __sparc */ ASSERT(bscv_held(ssp)); /* Set the timeout */ bscv_put8(ssp, chan_general, EBUS_IDX_WDOG_TIME, ssp->watchdog_timeout); /* Set whether to reset the system on timeout */ if (ssp->watchdog_reset_on_timeout) { set |= EBUS_WDOG_RST; } else { clear |= EBUS_WDOG_RST; } if (watchdog_activated) { set |= EBUS_WDOG_ENABLE; } else { clear |= EBUS_WDOG_ENABLE; } /* Set other host defaults */ clear |= (EBUS_WDOG_BREAK_DISABLE | EBUS_WDOG_AL3_FANPSU | EBUS_WDOG_AL3_WDOG); bscv_setclear8_volatile(ssp, chan_general, EBUS_IDX_WDOG_CTRL, set, clear); #if defined(__i386) || defined(__amd64) /* start the cyclic based watchdog patter */ mutex_enter(&cpu_lock); bscv_watchdog_cyclic_add(ssp); mutex_exit(&cpu_lock); #endif /* __i386 || __amd64 */ ssp->progress |= BSCV_WDOG_CFG; } /* * function - bscv_setup_hostname * description - setup the lom hostname if different from the nodename * inputs - soft state ptr * outputs - none */ static void bscv_setup_hostname(bscv_soft_state_t *ssp) { char host_nodename[128]; char lom_nodename[128]; size_t hostlen; size_t nodelen; ASSERT(bscv_held(ssp)); /* * Check machine label is the same as the * system nodename. */ (void) strncpy(host_nodename, utsname.nodename, sizeof (host_nodename)); /* read in lom hostname */ bscv_read_hostname(ssp, lom_nodename); /* Enforce null termination */ host_nodename[sizeof (host_nodename) - 1] = '\0'; lom_nodename[sizeof (lom_nodename) - 1] = '\0'; hostlen = (size_t)bscv_get8(ssp, chan_general, EBUS_IDX_HNAME_LENGTH); nodelen = (size_t)strlen(host_nodename); if ((nodelen > 0) && ((hostlen != nodelen) || (strcmp((const char *)&lom_nodename, (const char *)&host_nodename)) || (hostlen == 0))) { bscv_trace(ssp, 'A', "bscv_setup_hostname", "nodename(%s,%d) != bsc label(%s,%d)", host_nodename, nodelen, lom_nodename, hostlen); /* Write new label into LOM EEPROM */ bscv_write_hostname(ssp, host_nodename, (uint8_t)strlen(host_nodename)); } ssp->progress |= BSCV_HOSTNAME_DONE; } /* * function - bscv_read_hostname * description - read the current hostname from the lom * inputs - soft state pointer and buffer to store the hostname in. * outputs - none */ static void bscv_read_hostname(bscv_soft_state_t *ssp, char *lom_nodename) { int num_failures; boolean_t needretry; int length; int i; ASSERT(bscv_held(ssp)); /* * We have a special failure case here because a retry of a read * causes data to be lost. Thus we handle the retries ourselves * and are also responsible for detemining if the lom is faulty */ for (num_failures = 0; num_failures < BSC_FAILURE_RETRY_LIMIT; num_failures++) { bscv_clear_fault(ssp); length = bscv_get8(ssp, chan_general, EBUS_IDX_HNAME_LENGTH); if (bscv_faulty(ssp)) { needretry = 1; } else { needretry = 0; for (i = 0; i < length; i++) { lom_nodename[i] = bscv_get8_once(ssp, chan_general, EBUS_IDX_HNAME_CHAR); /* Retry on any error */ if (bscv_retcode(ssp) != 0) { needretry = 1; break; } } /* null terminate for strcmp later */ lom_nodename[length] = '\0'; } if (!needretry) { break; } /* Force the nodename to be empty */ lom_nodename[0] = '\0'; } if (needretry) { /* Failure - we ran out of retries */ cmn_err(CE_WARN, "bscv_read_hostname: retried %d times, giving up", num_failures); ssp->had_fault = B_TRUE; } else if (num_failures > 0) { bscv_trace(ssp, 'R', "bscv_read_hostname", "retried %d times, succeeded", num_failures); } } /* * function - bscv_write_hostname * description - write a new hostname to the lom * inputs - soft state pointer, pointer to new name, name length * outputs - none */ static void bscv_write_hostname(bscv_soft_state_t *ssp, char *host_nodename, uint8_t length) { int num_failures; boolean_t needretry; int i; ASSERT(bscv_held(ssp)); /* * We have a special failure case here because a retry of a read * causes data to be lost. Thus we handle the retries ourselves * and are also responsible for detemining if the lom is faulty */ for (num_failures = 0; num_failures < BSC_FAILURE_RETRY_LIMIT; num_failures++) { bscv_clear_fault(ssp); bscv_put8(ssp, chan_general, EBUS_IDX_HNAME_LENGTH, length); if (bscv_faulty(ssp)) { needretry = 1; } else { needretry = 0; for (i = 0; i < length; i++) { bscv_put8_once(ssp, chan_general, EBUS_IDX_HNAME_CHAR, host_nodename[i]); /* Retry on any error */ if (bscv_retcode(ssp) != 0) { needretry = 1; break; } } } if (!needretry) { break; } } if (needretry) { /* Failure - we ran out of retries */ cmn_err(CE_WARN, "bscv_write_hostname: retried %d times, giving up", num_failures); ssp->had_fault = B_TRUE; } else if (num_failures > 0) { bscv_trace(ssp, 'R', "bscv_write_hostname", "retried %d times, succeeded", num_failures); } } /* * function - bscv_setup_static_info * description - read in static information from the lom at attach time. * inputs - soft state ptr * outputs - none */ static void bscv_setup_static_info(bscv_soft_state_t *ssp) { uint8_t addr_space_ptr; uint16_t mask; uint8_t fanspeed; int oldtemps[MAX_TEMPS]; int8_t temp; int i; ASSERT(bscv_held(ssp)); /* * Finally read in some static info like device names, * shutdown enabled, etc before the queue starts. */ /* * To get the volts static info we need address space 2 */ bzero(&ssp->volts, sizeof (lom_volts_t)); ssp->volts.num = EBUS_CONFIG2_NSUPPLY_DEC( bscv_get8(ssp, chan_general, EBUS_IDX_CONFIG2)); if (ssp->volts.num > MAX_VOLTS) { cmn_err(CE_WARN, "lom: firmware reported too many voltage lines. "); cmn_err(CE_CONT, "Reported %d, maximum is %d", ssp->volts.num, MAX_VOLTS); ssp->volts.num = MAX_VOLTS; } bscv_trace(ssp, 'A', "bscv_setup_static_info", "num volts %d", ssp->volts.num); (void) bscv_read_env_name(ssp, EBUS_CMD_SPACE2, EBUS_IDX2_SUPPLY_NAME_START, EBUS_IDX2_SUPPLY_NAME_END, ssp->volts.name, ssp->volts.num); mask = bscv_get8(ssp, chan_general, BSCVA(EBUS_CMD_SPACE2, EBUS_IDX2_SUPPLY_FATAL_MASK1)) << 8; mask |= bscv_get8(ssp, chan_general, BSCVA(EBUS_CMD_SPACE2, EBUS_IDX2_SUPPLY_FATAL_MASK2)); for (i = 0; i < ssp->volts.num; i++) { ssp->volts.shutdown_enabled[i] = (((mask >> i) & 1) == 0) ? 0 : 1; } /* * Get the temperature static info and populate initial temperatures. * Do not destroy old temperature values if the new value is not * known i.e. if the device is inaccessible. */ bcopy(ssp->temps.temp, oldtemps, sizeof (oldtemps)); bzero(&ssp->temps, sizeof (lom_temp_t)); ssp->temps.num = EBUS_CONFIG2_NTEMP_DEC( bscv_get8(ssp, chan_general, EBUS_IDX_CONFIG2)); if (ssp->temps.num > MAX_TEMPS) { cmn_err(CE_WARN, "lom: firmware reported too many temperatures being " "monitored."); cmn_err(CE_CONT, "Reported %d, maximum is %d", ssp->temps.num, MAX_TEMPS); ssp->temps.num = MAX_TEMPS; } ssp->temps.num_ov = EBUS_CONFIG3_NOTEMP_DEC( bscv_get8(ssp, chan_general, EBUS_IDX_CONFIG3)); if (ssp->temps.num_ov > MAX_TEMPS) { cmn_err(CE_WARN, "lom: firmware reported too many over temperatures being " "monitored."); cmn_err(CE_CONT, "Reported %d, maximum is %d", ssp->temps.num_ov, MAX_TEMPS); ssp->temps.num_ov = MAX_TEMPS; } bscv_trace(ssp, 'A', "bscv_setup_static_info", "num temps %d, over temps %d", ssp->temps.num, ssp->temps.num_ov); addr_space_ptr = bscv_read_env_name(ssp, EBUS_CMD_SPACE4, EBUS_IDX4_TEMP_NAME_START, EBUS_IDX4_TEMP_NAME_END, ssp->temps.name, ssp->temps.num); for (i = 0; i < ssp->temps.num; i++) { ssp->temps.warning[i] = (int8_t)bscv_get8(ssp, chan_general, BSCVA(EBUS_CMD_SPACE4, EBUS_IDX4_TEMP_WARN1 + i)); /* * If shutdown is not enabled then set it as zero so * it is not displayed by the utility. */ if ((bscv_get8(ssp, chan_general, BSCVA(EBUS_CMD_SPACE4, EBUS_IDX4_TEMP_FATAL_MASK)) >> i) & 0x01) { ssp->temps.shutdown[i] = (int8_t)bscv_get8(ssp, chan_general, BSCVA(EBUS_CMD_SPACE4, EBUS_IDX4_TEMP_SDOWN1 + i)); } else { ssp->temps.shutdown[i] = 0; } } for (i = 0; i < ssp->temps.num; i++) { temp = bscv_get8(ssp, chan_general, EBUS_IDX_TEMP1 + i); if ((temp <= LOM_TEMP_MAX_VALUE) || (temp == LOM_TEMP_STATE_NOT_PRESENT)) { ssp->temps.temp[i] = temp; } else { /* New value is not known - use old value */ ssp->temps.temp[i] = oldtemps[i]; } } /* * Check for and skip a single 0xff character between the * temperature and over temperature names */ if (bscv_get8(ssp, chan_general, BSCVA(EBUS_CMD_SPACE4, addr_space_ptr)) == 0xff) { addr_space_ptr++; } (void) bscv_read_env_name(ssp, EBUS_CMD_SPACE4, addr_space_ptr, EBUS_IDX4_TEMP_NAME_END, ssp->temps.name_ov, ssp->temps.num_ov); /* * To get the CB static info we need address space 3 */ bzero(&ssp->sflags, sizeof (lom_sflags_t)); ssp->sflags.num = EBUS_CONFIG3_NBREAKERS_DEC(bscv_get8(ssp, chan_general, EBUS_IDX_CONFIG3)); if (ssp->sflags.num > MAX_STATS) { cmn_err(CE_WARN, "lom: firmware reported too many status flags."); cmn_err(CE_CONT, "Reported %d, maximum is %d", ssp->sflags.num, MAX_STATS); ssp->sflags.num = MAX_STATS; } bscv_trace(ssp, 'A', "bscv_setup_static_info", "num sflags %d", ssp->sflags.num); (void) bscv_read_env_name(ssp, EBUS_CMD_SPACE3, EBUS_IDX3_BREAKER_NAME_START, EBUS_IDX3_BREAKER_NAME_END, ssp->sflags.name, ssp->sflags.num); /* * To get the fan static info we need address space 5 */ ssp->num_fans = EBUS_CONFIG_NFAN_DEC( bscv_get8(ssp, chan_general, EBUS_IDX_CONFIG)); if (ssp->num_fans > MAX_FANS) { cmn_err(CE_WARN, "lom: firmware reported too many fans. "); cmn_err(CE_CONT, "Reported %d, maximum is %d", ssp->num_fans, MAX_FANS); ssp->num_fans = MAX_FANS; } for (i = 0; i < ssp->num_fans; i++) { fanspeed = bscv_get8(ssp, chan_general, EBUS_IDX_FAN1_SPEED + i); if ((fanspeed <= LOM_FAN_MAX_SPEED) || (fanspeed == LOM_FAN_NOT_PRESENT)) { /* * Do not destroy previous values unless the * value is definitive. */ ssp->fanspeed[i] = fanspeed; } } bscv_trace(ssp, 'A', "bscv_setup_static_info", "num fans %d", ssp->num_fans); (void) bscv_read_env_name(ssp, EBUS_CMD_SPACE5, EBUS_IDX5_FAN_NAME_START, EBUS_IDX5_FAN_NAME_END, ssp->fan_names, ssp->num_fans); /* Get led static information from address space 10 */ (void) bscv_read_env_name(ssp, EBUS_CMD_SPACE_LEDS, EBUS_IDX10_LED_NAME_START, EBUS_IDX10_LED_NAME_END, ssp->led_names, MAX_LED_ID); } /* * function - bscv_read_env_name * description - read in static environment names * warning changes address space and the caller relies * on this behaviour. * inputs - soft state ptr, chosen address space, * start of name data, end of name data, * name storage, number of names. * outputs - next address for reading name data. */ static uint8_t bscv_read_env_name(bscv_soft_state_t *ssp, uint8_t addr_space, uint8_t addr_start, uint8_t addr_end, char namebuf[][MAX_LOM2_NAME_STR], int numnames) { int i; int nameidx; int namemax; unsigned int addr_space_ptr; uint8_t this_char; ASSERT(bscv_held(ssp)); bscv_trace(ssp, 'A', "bscv_read_env_name", "bscv_read_env_name, space %d, start 0x%x, end 0x%x, numnames %d", addr_space, addr_start, addr_end, numnames); addr_space_ptr = addr_start; for (i = 0; i < numnames; i++) { nameidx = 0; namemax = sizeof (namebuf[i]); bzero(namebuf[i], namemax); while (addr_space_ptr <= addr_end) { /* * Read the current character. */ this_char = bscv_get8(ssp, chan_general, BSCVA(addr_space, addr_space_ptr)); if (this_char == 0xff) { /* * Ran out of names - this must * be the end of the name. * This is really an error because * we have just seen either a non-NUL * terminated string or the number of * strings did not match what was * reported. */ break; } /* * We increment the buffer pointer now so that * it is ready for the next read */ addr_space_ptr++; if (this_char == '\0') { /* Found end of string - done */ break; } if (nameidx < (namemax - 1)) { /* * Buffer not full - record character * NOTE we always leave room for the NUL * terminator. */ namebuf[i][nameidx++] = this_char; } } /* Ensure null termination */ namebuf[i][nameidx] = '\0'; } /* Clamp addr_space_ptr to 0xff because we return uint8_t */ if (addr_space_ptr > 0xff) { addr_space_ptr = 0xff; } return (addr_space_ptr); } /* * function - bscv_setup_events * description - initialise the event reporting code * inputs - soft state ptr * outputs - DDI_SUCCESS or DDI_FAILURE */ static void bscv_setup_events(bscv_soft_state_t *ssp) { uint8_t bits2set; uint8_t bits2clear; ASSERT(bscv_held(ssp)); /* * deal with event reporting - cover all cases */ bits2set = 0; bits2clear = 0; if (ssp->serial_reporting == LOM_SER_EVENTS_ON) { bits2clear |= EBUS_ALARM_NOEVENTS; } else if (ssp->serial_reporting == LOM_SER_EVENTS_OFF) { bits2set |= EBUS_ALARM_NOEVENTS; } else if (ssp->serial_reporting == LOM_SER_EVENTS_DEF) { bits2set |= EBUS_ALARM_NOEVENTS; } bscv_setclear8_volatile(ssp, chan_general, EBUS_IDX_ALARM, bits2set, bits2clear); } #ifdef __sparc /* * function - bscv_write_sig * description - write out a signature, taking care to deal with any strange * values for CPU ID * inputs - soft state ptr, signature * outputs - none */ static void bscv_write_sig(bscv_soft_state_t *ssp, bscv_sig_t s) { ASSERT(bscv_held(ssp)); /* Upload the signature */ bscv_put32(ssp, chan_cpusig, BSCVA(EBUS_CMD_SPACE_CPUSIG, EBUS_IDX11_CPU_SIG_MSB), s.sig_info.signature); /* * We always write the CPU ID last because this tells the firmware * that the signature is fully uploaded and therefore to consume the * data. This is required since the signature is > 1 byte in size * and we transmit data in single bytes. */ if (s.cpu == ~0) { /* ~0 means the signature applies to any CPU. */ bscv_put8(ssp, chan_cpusig, BSCVA(EBUS_CMD_SPACE_CPUSIG, EBUS_IDX11_CPU_ID), EBUS_ANY_CPU_ID); } else { if (s.cpu > 255) { /* * The CPU ID supplied is unexpectedly large. Lets * just use the bottom bits, in case other high order * bits are being used for special meaning. */ cmn_err(CE_WARN, "CPU Signature ID 0x%x > 255", s.cpu); s.cpu %= 256; cmn_err(CE_CONT, "using ID 0x%x instead ", s.cpu); } bscv_put8(ssp, chan_cpusig, BSCVA(EBUS_CMD_SPACE_CPUSIG, EBUS_IDX11_CPU_ID), (uint8_t)s.cpu); } ssp->last_sig = s; ssp->progress |= BSCV_SIG_SENT; } #endif /* __sparc */ #if defined(__i386) || defined(__amd64) /* * function - bscv_inform_bsc * description - inform bsc of driver state for logging purposes * inputs - driver soft state, state * outputs - none * */ static void bscv_inform_bsc(bscv_soft_state_t *ssp, uint32_t state) { ASSERT(bscv_held(ssp)); bscv_trace(ssp, 'X', "bscv_inform_bsc", "bscv_inform_bsc: state=%d", state); bscv_put32(ssp, chan_general, BSCVA(EBUS_CMD_SPACE_CPUSIG, EBUS_IDX11_CPU_SIG_MSB), state); bscv_put8(ssp, chan_cpusig, BSCVA(EBUS_CMD_SPACE_CPUSIG, EBUS_IDX11_CPU_ID), EBUS_ANY_CPU_ID); } /* * function - bscv_watchdog_pat_request * description - request a heartbeat pat * inputs - timeout value in seconds * outputs - none */ static void bscv_watchdog_pat_request(void *arg) { bscv_soft_state_t *ssp = (bscv_soft_state_t *)arg; bscv_wdog_do_pat(ssp); } /* * function - bscv_watchdog_cfg_request * description - request configuration of the bsc hardware watchdog * inputs - new state (0=disabled, 1=enabled) * outputs - one if successful, zero if unsuccesful */ static void bscv_watchdog_cfg_request(bscv_soft_state_t *ssp, uint8_t new_state) { ASSERT(new_state == WDOG_ON || new_state == WDOG_OFF); watchdog_activated = new_state; bscv_trace(ssp, 'X', "bscv_watchdog_cfg_request", "watchdog_activated=%d", watchdog_activated); bscv_write_wdog_cfg(ssp, bscv_watchdog_timeout_seconds, new_state, wdog_reset_on_timeout); } /* * function - bscv_set_watchdog_timer * description - setup the heartbeat timeout value * inputs - timeout value in seconds * outputs - zero if the value was not changed * otherwise the current value */ static uint_t bscv_set_watchdog_timer(bscv_soft_state_t *ssp, uint_t timeoutval) { bscv_trace(ssp, 'X', "bscv_set_watchdog_timer:", "timeout=%d", timeoutval); /* * We get started during bscv_attach only * if bscv_watchdog_enable is set. */ if (bscv_watchdog_available && (!watchdog_activated || (watchdog_activated && (timeoutval != bscv_watchdog_timeout_seconds)))) { bscv_watchdog_timeout_seconds = timeoutval; bscv_watchdog_cfg_request(ssp, WDOG_ON); return (bscv_watchdog_timeout_seconds); } return (0); } /* * function - bscv_clear_watchdog_timer * description - add the watchdog patter cyclic * inputs - driver soft state * outputs - value of watchdog timeout in seconds * * This function is a copy of the SPARC implementation * in the todblade clock driver. */ static void bscv_clear_watchdog_timer(bscv_soft_state_t *ssp) { bscv_trace(ssp, 'X', "bscv_clear_watchdog_timer", ""); if (bscv_watchdog_available && watchdog_activated) { bscv_watchdog_enable = 0; bscv_watchdog_cfg_request(ssp, WDOG_OFF); } } /* * function - bscv_panic_callback * description - called when we panic so we can disabled the watchdog * inputs - driver soft state pointer * outputs - DDI_SUCCESS */ /*ARGSUSED1*/ static boolean_t bscv_panic_callback(void *arg, int code) { bscv_soft_state_t *ssp = (bscv_soft_state_t *)arg; bscv_trace(ssp, 'X', "bscv_panic_callback", "disabling watchdog"); bscv_clear_watchdog_timer(ssp); /* * We dont get interrupts during the panic callback. But bscbus * takes care of all this */ bscv_full_stop(ssp); return (DDI_SUCCESS); } /* * function - bscv_watchdog_cyclic_add * description - add the watchdog patter cyclic * inputs - driver soft state * outputs - none */ static void bscv_watchdog_cyclic_add(bscv_soft_state_t *ssp) { cyc_handler_t hdlr; cyc_time_t when; ASSERT(MUTEX_HELD(&cpu_lock)); /* for cyclic_add */ if (ssp->cyclic_id != CYCLIC_NONE) { return; } hdlr.cyh_level = CY_LOCK_LEVEL; hdlr.cyh_func = (cyc_func_t)bscv_watchdog_pat_request; hdlr.cyh_arg = (void *)ssp; when.cyt_when = 0; when.cyt_interval = WATCHDOG_PAT_INTERVAL; ssp->cyclic_id = cyclic_add(&hdlr, &when); bscv_trace(ssp, 'X', "bscv_watchdog_cyclic_add:", "cyclic added"); } /* * function - bscv_watchdog_cyclic_remove * description - remove the watchdog patter cyclic * inputs - soft state ptr * outputs - none */ static void bscv_watchdog_cyclic_remove(bscv_soft_state_t *ssp) { ASSERT(MUTEX_HELD(&cpu_lock)); /* for cyclic_remove */ if (ssp->cyclic_id == CYCLIC_NONE) { return; } cyclic_remove(ssp->cyclic_id); ssp->cyclic_id = CYCLIC_NONE; bscv_trace(ssp, 'X', "bscv_watchdog_cyclic_remove:", "cyclic removed"); } #endif /* __i386 || __amd64 */ /* * General utility routines ... */ #ifdef DEBUG static void bscv_trace(bscv_soft_state_t *ssp, char code, const char *caller, const char *fmt, ...) { char buf[256]; char *p; va_list va; if (ssp->debug & (1 << (code-'@'))) { p = buf; (void) snprintf(p, sizeof (buf) - (p - buf), "%s/%s: ", MYNAME, caller); p += strlen(p); va_start(va, fmt); (void) vsnprintf(p, sizeof (buf) - (p - buf), fmt, va); va_end(va); buf[sizeof (buf) - 1] = '\0'; (void) strlog((short)ssp->majornum, (short)ssp->minornum, code, SL_TRACE, buf); } } #else /* DEBUG */ _NOTE(ARGSUSED(0)) static void bscv_trace(bscv_soft_state_t *ssp, char code, const char *caller, const char *fmt, ...) { } #endif /* DEBUG */