1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26
27 /*
28 * bscv.c - multi-threaded lom driver for the Stiletto platform.
29 */
30
31 /*
32 * Included files.
33 */
34
35 #include <sys/note.h>
36 #include <sys/types.h>
37 #include <sys/param.h>
38 #include <sys/uio.h>
39 #include <sys/open.h>
40 #include <sys/cred.h>
41 #include <sys/stream.h>
42 #include <sys/systm.h>
43 #include <sys/conf.h>
44 #include <sys/reboot.h>
45 #include <sys/modctl.h>
46 #include <sys/mkdev.h>
47 #include <sys/errno.h>
48 #include <sys/debug.h>
49 #include <sys/kmem.h>
50 #include <sys/consdev.h>
51 #include <sys/file.h>
52 #include <sys/stat.h>
53 #include <sys/disp.h>
54 #include <sys/ddi.h>
55 #include <sys/sunddi.h>
56 #include <sys/stream.h>
57 #include <sys/strlog.h>
58 #include <sys/log.h>
59 #include <sys/utsname.h>
60 #include <sys/callb.h>
61 #include <sys/sysevent.h>
62 #include <sys/nvpair.h>
63 #include <sys/sysevent/eventdefs.h>
64 #include <sys/sysevent/domain.h>
65 #include <sys/sysevent/env.h>
66 #include <sys/sysevent/dr.h>
67
68 #include <sys/lom_io.h>
69 #include <sys/bscbus.h>
70 #include <sys/bscv_impl.h>
71
72 /*
73 * Variables defined here and visible internally only
74 */
75
76 static void *bscv_statep = NULL;
77
78 /*
79 * Forward declarations
80 */
81
82 static int bscv_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
83 static int bscv_attach(dev_info_t *, ddi_attach_cmd_t);
84 static int bscv_detach(dev_info_t *, ddi_detach_cmd_t);
85 static int bscv_quiesce(dev_info_t *);
86 static int bscv_map_regs(bscv_soft_state_t *);
87 static void bscv_unmap_regs(bscv_soft_state_t *);
88 static void bscv_map_chan_logical_physical(bscv_soft_state_t *);
89
90 static int bscv_open(dev_t *, int, int, cred_t *);
91 static int bscv_close(dev_t, int, int, cred_t *);
92 static void bscv_full_stop(bscv_soft_state_t *);
93
94 static void bscv_enter(bscv_soft_state_t *);
95 static int bscv_tryenter(bscv_soft_state_t *ssp);
96 static void bscv_exit(bscv_soft_state_t *);
97 #ifdef DEBUG
98 static int bscv_held(bscv_soft_state_t *);
99 #endif /* DEBUG */
100
101 static void bscv_put8(bscv_soft_state_t *, int, bscv_addr_t, uint8_t);
102 static void bscv_put16(bscv_soft_state_t *, int, bscv_addr_t, uint16_t);
103 static void bscv_put32(bscv_soft_state_t *, int, bscv_addr_t, uint32_t);
104 static uint8_t bscv_get8(bscv_soft_state_t *, int, bscv_addr_t);
105 static uint16_t bscv_get16(bscv_soft_state_t *, int, bscv_addr_t);
106 static uint32_t bscv_get32(bscv_soft_state_t *, int, bscv_addr_t);
107 static void bscv_setclear8(bscv_soft_state_t *, int,
108 bscv_addr_t, uint8_t, uint8_t);
109 static void bscv_setclear8_volatile(bscv_soft_state_t *, int,
110 bscv_addr_t, uint8_t, uint8_t);
111 static void bscv_rep_rw8(bscv_soft_state_t *, int,
112 uint8_t *, bscv_addr_t, size_t, uint_t, boolean_t);
113 static uint8_t bscv_get8_cached(bscv_soft_state_t *, bscv_addr_t);
114
115 static uint8_t bscv_get8_locked(bscv_soft_state_t *, int, bscv_addr_t, int *);
116 static void bscv_rep_get8_locked(bscv_soft_state_t *, int,
117 uint8_t *, bscv_addr_t, size_t, uint_t, int *);
118
119 static boolean_t bscv_faulty(bscv_soft_state_t *);
120 static void bscv_clear_fault(bscv_soft_state_t *);
121 static void bscv_set_fault(bscv_soft_state_t *);
122 static boolean_t bscv_session_error(bscv_soft_state_t *);
123 static int bscv_retcode(bscv_soft_state_t *);
124 static int bscv_should_retry(bscv_soft_state_t *);
125 static void bscv_locked_result(bscv_soft_state_t *, int *);
126
127 static void bscv_put8_once(bscv_soft_state_t *, int, bscv_addr_t, uint8_t);
128 static uint8_t bscv_get8_once(bscv_soft_state_t *, int, bscv_addr_t);
129 static uint32_t bscv_probe(bscv_soft_state_t *, int, uint32_t *);
130 static void bscv_resync_comms(bscv_soft_state_t *, int);
131
132 static boolean_t bscv_window_setup(bscv_soft_state_t *);
133 static int bscv_eerw(bscv_soft_state_t *, uint32_t, uint8_t *,
134 unsigned, boolean_t);
135
136 static int bscv_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
137 static int bscv_ioc_dogstate(bscv_soft_state_t *, intptr_t, int);
138 static int bscv_ioc_psustate(bscv_soft_state_t *, intptr_t, int);
139 static int bscv_ioc_fanstate(bscv_soft_state_t *, intptr_t, int);
140 static int bscv_ioc_fledstate(bscv_soft_state_t *, intptr_t, int);
141 static int bscv_ioc_ledstate(bscv_soft_state_t *, intptr_t, int);
142 static int bscv_ioc_info(bscv_soft_state_t *, intptr_t, int);
143 static int bscv_ioc_mread(bscv_soft_state_t *, intptr_t, int);
144 static int bscv_ioc_volts(bscv_soft_state_t *, intptr_t, int);
145 static int bscv_ioc_stats(bscv_soft_state_t *, intptr_t, int);
146 static int bscv_ioc_temp(bscv_soft_state_t *, intptr_t, int);
147 static int bscv_ioc_cons(bscv_soft_state_t *, intptr_t, int);
148 static int bscv_ioc_eventlog2(bscv_soft_state_t *, intptr_t, int);
149 static int bscv_ioc_info2(bscv_soft_state_t *, intptr_t, int);
150 static int bscv_ioc_test(bscv_soft_state_t *, intptr_t, int);
151 static int bscv_ioc_mprog2(bscv_soft_state_t *, intptr_t, int);
152 static int bscv_ioc_mread2(bscv_soft_state_t *, intptr_t, int);
153
154 static void bscv_event_daemon(void *);
155 static void bscv_start_event_daemon(bscv_soft_state_t *);
156 static int bscv_stop_event_daemon(bscv_soft_state_t *);
157 static int bscv_pause_event_daemon(bscv_soft_state_t *);
158 static void bscv_resume_event_daemon(bscv_soft_state_t *);
159 static void bscv_event_process(bscv_soft_state_t *ssp, boolean_t);
160 static int bscv_event_validate(bscv_soft_state_t *, uint32_t, uint8_t);
161 static void bscv_event_process_one(bscv_soft_state_t *, lom_event_t *);
162 static void bscv_build_eventstring(bscv_soft_state_t *,
163 lom_event_t *, char *, char *);
164 static int bscv_level_of_event(lom_event_t *);
165 static void bscv_status(bscv_soft_state_t *, uint8_t, uint8_t);
166 char *bscv_get_label(char [][MAX_LOM2_NAME_STR], int, int);
167 static void bscv_generic_sysevent(bscv_soft_state_t *, char *, char *, char *,
168 char *, int32_t, char *);
169 static void bscv_sysevent(bscv_soft_state_t *, lom_event_t *);
170
171 static int bscv_prog(bscv_soft_state_t *, intptr_t, int);
172 static int bscv_prog_image(bscv_soft_state_t *, boolean_t,
173 uint8_t *, int, uint32_t);
174 static int bscv_prog_receive_image(bscv_soft_state_t *, lom_prog_t *,
175 uint8_t *, int);
176 static void bscv_leave_programming_mode(bscv_soft_state_t *, boolean_t);
177 static int bscv_prog_stop_lom(bscv_soft_state_t *);
178 static int bscv_prog_start_lom(bscv_soft_state_t *);
179
180 static int bscv_attach_common(bscv_soft_state_t *);
181 static int bscv_cleanup(bscv_soft_state_t *);
182 static void bscv_setup_capability(bscv_soft_state_t *);
183 static int bscv_probe_check(bscv_soft_state_t *);
184 static void bscv_setup_hostname(bscv_soft_state_t *);
185 static void bscv_read_hostname(bscv_soft_state_t *, char *);
186 static void bscv_write_hostname(bscv_soft_state_t *, char *, uint8_t);
187 static void bscv_setup_static_info(bscv_soft_state_t *);
188 static uint8_t bscv_read_env_name(bscv_soft_state_t *, uint8_t,
189 uint8_t, uint8_t, char [][MAX_LOM2_NAME_STR], int);
190 static void bscv_setup_events(bscv_soft_state_t *);
191
192 static void bscv_trace(bscv_soft_state_t *, char, const char *,
193 const char *, ...);
194
195 #ifdef __sparc
196 static void bscv_idi_init();
197 static void bscv_idi_fini();
198 static void bscv_idi_new_instance(dev_info_t *dip);
199 static void bscv_idi_clear_err();
200 void bscv_idi_set(struct bscv_idi_info info);
201 static boolean_t bscv_idi_err();
202 static boolean_t bscv_nodename_set(struct bscv_idi_info info);
203 static boolean_t bscv_sig_set(struct bscv_idi_info info);
204 static boolean_t bscv_wdog_pat(struct bscv_idi_info info);
205 static boolean_t bscv_wdog_cfg(struct bscv_idi_info info);
206 static void bscv_write_sig(bscv_soft_state_t *ssp, bscv_sig_t s);
207 #endif /* __sparc */
208
209 static void bscv_setup_watchdog(bscv_soft_state_t *ssp);
210 static void bscv_write_wdog_cfg(bscv_soft_state_t *,
211 uint_t, boolean_t, uint8_t);
212
213 #if defined(__i386) || defined(__amd64)
214 static void bscv_inform_bsc(bscv_soft_state_t *, uint32_t);
215 static void bscv_watchdog_pat_request(void *);
216 static void bscv_watchdog_cfg_request(bscv_soft_state_t *, uint8_t);
217 static uint_t bscv_set_watchdog_timer(bscv_soft_state_t *, uint_t);
218 static void bscv_clear_watchdog_timer(bscv_soft_state_t *);
219
220 static boolean_t bscv_panic_callback(void *, int);
221 static void bscv_watchdog_cyclic_add(bscv_soft_state_t *);
222 static void bscv_watchdog_cyclic_remove(bscv_soft_state_t *);
223
224 static uint8_t wdog_reset_on_timeout = 1;
225
226 #define WDOG_ON 1
227 #define WDOG_OFF 0
228 #define CLK_WATCHDOG_DEFAULT 10 /* 10 seconds */
229 #define WATCHDOG_PAT_INTERVAL 1000000000 /* 1 second */
230
231 static int bscv_watchdog_enable;
232 static int bscv_watchdog_available;
233 static int watchdog_activated;
234 static uint_t bscv_watchdog_timeout_seconds;
235 #endif /* __i386 || __amd64 */
236
237 #ifdef __sparc
238 struct bscv_idi_callout bscv_idi_callout_table[] = {
239 {BSCV_IDI_NODENAME, &bscv_nodename_set },
240 {BSCV_IDI_SIG, &bscv_sig_set },
241 {BSCV_IDI_WDOG_PAT, &bscv_wdog_pat },
242 {BSCV_IDI_WDOG_CFG, &bscv_wdog_cfg },
243 {BSCV_IDI_NULL, NULL }
244 };
245
246 static struct bscv_idi_callout_mgr bscv_idi_mgr;
247 #endif /* __sparc */
248
249 /*
250 * Local Definitions
251 */
252 #define STATUS_READ_LIMIT 8 /* Read up to 8 status changes at a time */
253 #define MYNAME "bscv"
254 #define BSCV_INST_TO_MINOR(i) (i)
255 #define BSCV_MINOR_TO_INST(m) (m)
256
257 /*
258 * Strings for daemon event reporting
259 */
260
261 static char *eventSubsysStrings[] =
262 { "", /* 00 */
263 "Alarm ", /* 01 */
264 "temperature sensor ", /* 02 */
265 "overheat sensor ", /* 03 */
266 "Fan ", /* 04 */
267 "supply rail ", /* 05 */
268 "circuit breaker ", /* 06 */
269 "PSU ", /* 07 */
270 "user ", /* 08 */
271 "phonehome ", /* 09; unutilized */
272 "LOM ", /* 0a */
273 "host ", /* 0b */
274 "event log ", /* 0c */
275 "", /* 0d; EVENT_SUBSYS_EXTRA unutilized */
276 "LED ", /* 0e */
277 };
278
279 static char *eventTypeStrings[] =
280 {
281 "[null event]", /* 00 */
282 "ON", /* 01 */
283 "OFF", /* 02 */
284 "state change", /* 03 */
285 "power on", /* 04 */
286 "power off", /* 05 */
287 "powered off unexpectedly", /* 06 */
288 "reset unexpectedly", /* 07 */
289 "booted", /* 08 */
290 "watchdog enabled", /* 09 */
291 "watchdog disabled", /* 0a */
292 "watchdog triggered", /* 0b */
293 "failed", /* 0c */
294 "recovered", /* 0d */
295 "reset", /* 0e */
296 "XIR reset", /* 0f */
297 "console selected", /* 10 */
298 "time reference", /* 11 */
299 "script failure", /* 12 */
300 "modem access failure", /* 13 */
301 "modem dialing failure", /* 14 */
302 "bad checksum", /* 15 */
303 "added", /* 16 */
304 "removed", /* 17 */
305 "changed", /* 18 */
306 "login", /* 19 */
307 "password changed", /* 1a */
308 "login failed", /* 1b */
309 "logout", /* 1c */
310 "flash download", /* 1d */
311 "data lost", /* 1e */
312 "device busy", /* 1f */
313 "fault led state", /* 20 */
314 "overheat", /* 21 */
315 "severe overheat", /* 22 */
316 "no overheat", /* 23 */
317 "SCC", /* 24 */
318 "device inaccessible", /* 25 */
319 "Hostname change", /* 26 */
320 "CPU signature timeout", /* 27 */
321 "Bootmode change", /* 28 */
322 "Watchdog change policy", /* 29 */
323 "Watchdog change timeout", /* 2a */
324 };
325
326 /*
327 * These store to mapping between the logical service, e.g. chan_prog for
328 * programming, and the actual Xbus channel which carries that traffic.
329 * Any services can be shared on the same channel apart from chan_wdogpat.
330 */
331 static int chan_general; /* General Traffic */
332 static int chan_wdogpat; /* Watchdog Patting */
333 static int chan_cpusig; /* CPU signatures */
334 static int chan_eeprom; /* EEPROM I/O */
335 static int chan_prog; /* Programming */
336
337 /*
338 * cb_ops structure defining the driver entry points
339 */
340
341 static struct cb_ops bscv_cb_ops = {
342 bscv_open, /* open */
343 bscv_close, /* close */
344 nodev, /* strategy */
345 nodev, /* print */
346 nodev, /* dump */
347 nodev, /* read */
348 nodev, /* write */
349 bscv_ioctl, /* ioctl */
350 nodev, /* devmap */
351 nodev, /* mmap */
352 nodev, /* segmap */
353 nochpoll, /* poll */
354 ddi_prop_op, /* prop op */
355 NULL, /* ! STREAMS */
356 D_NEW | D_MP /* MT/MP Safe */
357 };
358
359 /*
360 * dev_ops structure defining autoconfiguration driver autoconfiguration
361 * routines
362 */
363
364 static struct dev_ops bscv_dev_ops = {
365 DEVO_REV, /* devo_rev */
366 0, /* devo_refcnt */
367 bscv_getinfo, /* devo_getinfo */
368 nulldev, /* devo_identify */
369 nulldev, /* devo_probe */
370 bscv_attach, /* devo_attach */
371 bscv_detach, /* devo_detach */
372 nodev, /* devo_reset */
373 &bscv_cb_ops, /* devo_cb_ops */
374 (struct bus_ops *)0, /* devo_bus_ops */
375 NULL, /* devo_power */
376 bscv_quiesce, /* devo_quiesce */
377 };
378
379 /*
380 * module configuration section
381 */
382
383 #ifdef DEBUG
384 #define BSCV_VERSION_STRING "bscv driver - Debug"
385 #else /* DEBUG */
386 #define BSCV_VERSION_STRING "bscv driver"
387 #endif /* DEBUG */
388
389 static struct modldrv modldrv = {
390 &mod_driverops,
391 BSCV_VERSION_STRING,
392 &bscv_dev_ops,
393 };
394
395 static struct modlinkage modlinkage = {
396 MODREV_1,
397 &modldrv,
398 NULL
399 };
400
401 #ifdef DEBUG
402 /* Tracing is enabled if value is non-zero. */
403 static int bscv_trace_flag = 1;
404
405 #define BSCV_TRACE if (bscv_trace_flag != 0) bscv_trace
406 #else
407 #define BSCV_TRACE
408 #endif
409
410 /*
411 * kernel accessible routines. These routines are necessarily global so the
412 * driver can be loaded, and unloaded successfully
413 */
414
415 /*
416 * function - _init
417 * description - initializes the driver state structure and installs the
418 * driver module into the kernel
419 * inputs - none
420 * outputs - success or failure of module installation
421 */
422
423 int
424 _init(void)
425 {
426 register int e;
427
428 if ((e = ddi_soft_state_init(&bscv_statep,
429 sizeof (bscv_soft_state_t), 1)) != 0) {
430 return (e);
431 }
432
433 if ((e = mod_install(&modlinkage)) != 0) {
434 ddi_soft_state_fini(&bscv_statep);
435 }
436
437 #ifdef __sparc
438 if (e == 0) bscv_idi_init();
439 #endif /* __sparc */
440 return (e);
441 }
442
443 /*
444 * function - _info
445 * description - provide information about a kernel loaded module
446 * inputs - module infomation
447 * outputs - success or failure of information request
448 */
449
450 int
451 _info(struct modinfo *modinfop)
452 {
453 return (mod_info(&modlinkage, modinfop));
454 }
455
456 /*
457 * function - _fini
458 * description - removes a module from the kernel and frees the driver soft
459 * state memory
460 * inputs - none
461 * outputs - success or failure of module removal
462 */
463
464 int
465 _fini(void)
466 {
467 register int e;
468
469 if ((e = mod_remove(&modlinkage)) != 0) {
470 return (e);
471 }
472
473 #ifdef __sparc
474 bscv_idi_fini();
475 #endif /* __sparc */
476 ddi_soft_state_fini(&bscv_statep);
477
478 return (e);
479 }
480
481 /*
482 * function - bscv_getinfo
483 * description - routine used to provide information on the driver
484 * inputs - device information structure, command, command arg, storage
485 * area for the result
486 * outputs - DDI_SUCCESS or DDI_FAILURE
487 */
488
489 /*ARGSUSED*/
490 static int
491 bscv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
492 {
493 bscv_soft_state_t *ssp;
494 dev_t dev = (dev_t)arg;
495 int instance;
496 int error;
497
498 instance = DEVICETOINSTANCE(dev);
499
500 switch (cmd) {
501 case DDI_INFO_DEVT2INSTANCE:
502 *result = (void *)(uintptr_t)instance;
503 error = DDI_SUCCESS;
504 break;
505
506 case DDI_INFO_DEVT2DEVINFO:
507 ssp = ddi_get_soft_state(bscv_statep, instance);
508 if (ssp == NULL)
509 return (DDI_FAILURE);
510 *result = (void *) ssp->dip;
511 error = DDI_SUCCESS;
512 break;
513
514 default:
515 error = DDI_FAILURE;
516 break;
517 }
518
519 return (error);
520 }
521
522 #ifdef __sparc
523 void
524 bscv_idi_init()
525 {
526 bscv_idi_mgr.valid_inst = (uint32_t)~0; /* No valid instances */
527 bscv_idi_mgr.tbl = bscv_idi_callout_table;
528 bscv_idi_mgr.errs = 0;
529
530 /*
531 * Now that all fields are initialized, set the magic flag. This is
532 * a kind of integrity check for the data structure.
533 */
534 bscv_idi_mgr.magic = BSCV_IDI_CALLOUT_MAGIC;
535 }
536
537 static void
538 bscv_idi_clear_err()
539 {
540 ASSERT(bscv_idi_mgr.magic == BSCV_IDI_CALLOUT_MAGIC);
541
542 bscv_idi_mgr.errs = 0;
543 }
544
545 /*
546 * function - bscv_idi_err
547 * description - error messaging service which throttles the number of error
548 * messages to avoid overflowing storage
549 * inputs - none
550 * returns - boolean to indicate whether a message should be reported
551 * side-effects - updates the error number counter
552 */
553 static boolean_t
554 bscv_idi_err()
555 {
556 ASSERT(bscv_idi_mgr.magic == BSCV_IDI_CALLOUT_MAGIC);
557
558 bscv_idi_mgr.errs++;
559
560 if (bscv_idi_mgr.errs++ < BSCV_IDI_ERR_MSG_THRESHOLD)
561 return (B_TRUE);
562
563 return (B_FALSE);
564 }
565
566 void
567 bscv_idi_new_instance(dev_info_t *dip)
568 {
569 ASSERT(bscv_idi_mgr.magic == BSCV_IDI_CALLOUT_MAGIC);
570
571 /*
572 * We don't care how many instances we have, or their value, so long
573 * as we have at least one valid value. This is so service routines
574 * can get any required locks via a soft state pointer.
575 */
576 if (bscv_idi_mgr.valid_inst == (uint32_t)~0) {
577 bscv_idi_mgr.valid_inst = ddi_get_instance(dip);
578 }
579 }
580
581 void
582 bscv_idi_fini()
583 {
584 bscv_idi_mgr.valid_inst = (uint32_t)~0; /* No valid instances */
585 bscv_idi_mgr.tbl = NULL;
586 }
587 #endif /* __sparc */
588
589 /*
590 * function - bscv_attach
591 * description - this routine is responsible for setting aside memory for the
592 * driver data structures, initialising the mutexes and creating
593 * the device minor nodes. Additionally, this routine calls the
594 * the callback routine.
595 * inputs - device information structure, DDI_ATTACH command
596 * outputs - DDI_SUCCESS or DDI_FAILURE
597 */
598
599 int
600 bscv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
601 {
602 bscv_soft_state_t *ssp;
603 int instance;
604
605 switch (cmd) {
606 case DDI_ATTACH:
607
608 instance = ddi_get_instance(dip);
609
610 if (ddi_soft_state_zalloc(bscv_statep, instance) !=
611 DDI_SUCCESS) {
612 return (DDI_FAILURE);
613 }
614
615
616 ssp = ddi_get_soft_state(bscv_statep, instance);
617
618 ssp->progress = 0;
619
620 ssp->dip = dip;
621 ssp->instance = instance;
622 ssp->event_waiting = B_FALSE;
623 ssp->status_change = B_FALSE;
624 ssp->nodename_change = B_FALSE;
625 ssp->cap0 = 0;
626 ssp->cap1 = 0;
627 ssp->cap2 = 0;
628 ssp->prog_mode_only = B_FALSE;
629 ssp->programming = B_FALSE;
630 ssp->cssp_prog = B_FALSE;
631 ssp->task_flags = 0;
632 ssp->debug = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
633 DDI_PROP_DONTPASS, "debug", 0);
634 ssp->majornum = ddi_driver_major(dip);
635 ssp->minornum = BSCV_INST_TO_MINOR(instance);
636 #if defined(__i386) || defined(__amd64)
637 ssp->last_nodename[0] = '\0';
638 #endif /* __i386 || __amd64 */
639
640 /*
641 * initialise the mutexes
642 */
643
644 mutex_init(&ssp->cmd_mutex, NULL, MUTEX_DRIVER, NULL);
645
646 mutex_init(&ssp->task_mu, NULL, MUTEX_DRIVER, NULL);
647 cv_init(&ssp->task_cv, NULL, CV_DRIVER, NULL);
648 cv_init(&ssp->task_evnt_cv, NULL, CV_DRIVER, NULL);
649 mutex_init(&ssp->prog_mu, NULL, MUTEX_DRIVER, NULL);
650 ssp->progress |= BSCV_LOCKS;
651
652 BSCV_TRACE(ssp, 'A', "bscv_attach",
653 "bscv_attach: mutexes and condition vars initialised");
654
655 /* Map in physical communication channels */
656
657 if (bscv_map_regs(ssp) != DDI_SUCCESS) {
658 (void) bscv_cleanup(ssp);
659 return (DDI_FAILURE);
660 }
661 ssp->progress |= BSCV_MAPPED_REGS;
662
663 /* Associate logical channels to physical channels */
664
665 bscv_map_chan_logical_physical(ssp);
666
667 bscv_enter(ssp);
668
669 bscv_leave_programming_mode(ssp, B_FALSE);
670
671 if (bscv_attach_common(ssp) == DDI_FAILURE) {
672 bscv_exit(ssp);
673 (void) bscv_cleanup(ssp);
674 return (DDI_FAILURE);
675 }
676
677 #ifdef __sparc
678 /*
679 * At this point the inter-driver-interface is made available.
680 * The IDI uses the event thread service which
681 * bscv_attach_common() sets up.
682 */
683 bscv_idi_new_instance(dip);
684 #endif /* __sparc */
685
686 bscv_exit(ssp);
687
688 /*
689 * now create the minor nodes
690 */
691 if (ddi_create_minor_node(ssp->dip, "lom", S_IFCHR,
692 BSCV_INST_TO_MINOR(instance),
693 DDI_PSEUDO, 0) != DDI_SUCCESS) {
694 (void) bscv_cleanup(ssp);
695 return (DDI_FAILURE);
696 }
697 BSCV_TRACE(ssp, 'A', "bscv_attach",
698 "bscv_attach: device minor nodes created");
699 ssp->progress |= BSCV_NODES;
700
701 if (!ssp->prog_mode_only)
702 bscv_start_event_daemon(ssp);
703
704 #if defined(__i386) || defined(__amd64)
705 bscv_watchdog_enable = 1;
706 bscv_watchdog_available = 1;
707 watchdog_activated = 0;
708 bscv_watchdog_timeout_seconds = CLK_WATCHDOG_DEFAULT;
709
710 if (bscv_watchdog_enable && (boothowto & RB_DEBUG)) {
711 bscv_watchdog_available = 0;
712 cmn_err(CE_WARN, "bscv: kernel debugger "
713 "detected: hardware watchdog disabled");
714 }
715
716 /*
717 * Before we enable the watchdog - register the panic
718 * callback so that we get called to stop the watchdog
719 * in the case of a panic.
720 */
721 ssp->callb_id = callb_add(bscv_panic_callback,
722 (void *)ssp, CB_CL_PANIC, "");
723
724 if (bscv_watchdog_available) {
725 (void) bscv_set_watchdog_timer(ssp,
726 CLK_WATCHDOG_DEFAULT);
727 bscv_enter(ssp);
728 bscv_setup_watchdog(ssp); /* starts cyclic callback */
729 bscv_exit(ssp);
730 }
731 #endif /* __i386 || __amd64 */
732 ddi_report_dev(dip);
733 return (DDI_SUCCESS);
734 default:
735 return (DDI_FAILURE);
736 }
737 }
738
739 /*
740 * function - bscv_detach
741 * description - routine that prepares a module to be unloaded. It undoes all
742 * the work done by the bscv_attach)() routine. This is
743 * facilitated by the use of the progress indicator
744 * inputs - device information structure, DDI_DETACH command
745 * outputs - DDI_SUCCESS or DDI_FAILURE
746 */
747
748 /*ARGSUSED*/
749 static int
750 bscv_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
751 {
752 return (DDI_FAILURE);
753 }
754
755 /*
756 * quiesce(9E) entry point.
757 *
758 * This function is called when the system is single-threaded at high
759 * PIL with preemption disabled. Therefore, this function must not be
760 * blocked.
761 *
762 * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
763 * DDI_FAILURE indicates an error condition and should almost never happen.
764 */
765 static int
766 bscv_quiesce(dev_info_t *dip)
767 {
768 bscv_soft_state_t *ssp;
769 int instance;
770
771
772 instance = ddi_get_instance(dip);
773 ssp = ddi_get_soft_state(bscv_statep, instance);
774 if (ssp == NULL) {
775 return (DDI_FAILURE);
776 }
777 #ifdef DEBUG
778 /* Disable tracing, as we are executing at High-Interrupt level */
779 bscv_trace_flag = 0;
780 #endif
781 /* quiesce the device */
782 bscv_full_stop(ssp);
783
784 return (DDI_SUCCESS);
785 }
786
787 /*
788 * cb_ops routines
789 */
790
791 /*
792 * function - bscv_open
793 * description - routine to provide association between user fd and device
794 * minor number. This routine is necessarily simple since a
795 * read/write interface is not provided. Additionally, the
796 * driver does not enforce exclusive access (FEXCL) or
797 * non-blocking during an open (FNDELAY). Deferred attach is
798 * supported.
799 * inputs - device number, flag specifying open type, device type,
800 * permissions
801 * outputs - success or failure of operation
802 */
803
804 /*ARGSUSED*/
805 static int
806 bscv_open(dev_t *devp, int flag, int otype, cred_t *cred)
807 {
808 bscv_soft_state_t *ssp;
809 int instance;
810
811 instance = DEVICETOINSTANCE(*devp);
812 ssp = ddi_get_soft_state(bscv_statep, instance);
813 if (ssp == NULL) {
814 return (ENXIO); /* not attached yet */
815 }
816 BSCV_TRACE(ssp, 'O', "bscv_open", "instance 0x%x", instance);
817
818 if (otype != OTYP_CHR) {
819 return (EINVAL);
820 }
821
822 return (0);
823 }
824
825 /*
826 * function - bscv_close
827 * description - routine to perform the final close on the device. As per the
828 * open routine, neither FEXCL or FNDELAY accesses are enforced
829 * by the driver.
830 * inputs - device number,flag specifying open type, device type,
831 * permissions
832 * outputs - success or failure of operation
833 */
834
835 /*ARGSUSED1*/
836 static int
837 bscv_close(dev_t dev, int flag, int otype, cred_t *cred)
838 {
839 bscv_soft_state_t *ssp;
840 int instance;
841
842 instance = DEVICETOINSTANCE(dev);
843 ssp = ddi_get_soft_state(bscv_statep, instance);
844 if (ssp == NULL) {
845 return (ENXIO);
846 }
847 BSCV_TRACE(ssp, 'O', "bscv_close", "instance 0x%x", instance);
848
849 return (0);
850 }
851
852 static int
853 bscv_map_regs(bscv_soft_state_t *ssp)
854 {
855 int i;
856 int retval;
857 int *props;
858 unsigned int nelements;
859
860 ASSERT(ssp);
861
862 ssp->nchannels = 0;
863
864 /*
865 * Work out how many channels are available by looking at the number
866 * of elements of the regs property array.
867 */
868 retval = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, ssp->dip,
869 DDI_PROP_DONTPASS, "reg", &props, &nelements);
870
871 /* We don't need props anymore. Free memory if it was allocated */
872 if (retval == DDI_PROP_SUCCESS)
873 ddi_prop_free(props);
874
875 /* Check for sanity of nelements */
876 if (retval != DDI_PROP_SUCCESS) {
877 BSCV_TRACE(ssp, 'A', "bscv_map_regs", "lookup reg returned"
878 " 0x%x", retval);
879 goto cleanup_exit;
880 } else if (nelements % LOMBUS_REGSPEC_SIZE != 0) {
881 BSCV_TRACE(ssp, 'A', "bscv_map_regs", "nelements %d not"
882 " a multiple of %d", nelements, LOMBUS_REGSPEC_SIZE);
883 goto cleanup_exit;
884 } else if (nelements > BSCV_MAXCHANNELS * LOMBUS_REGSPEC_SIZE) {
885 BSCV_TRACE(ssp, 'A', "bscv_map_regs", "nelements %d too large"
886 ", probably a misconfiguration", nelements);
887 goto cleanup_exit;
888 } else if (nelements < BSCV_MINCHANNELS * LOMBUS_REGSPEC_SIZE) {
889 BSCV_TRACE(ssp, 'A', "bscv_map_regs", "nelements %d too small"
890 ", need to have at least a general and a wdog channel",
891 nelements);
892 goto cleanup_exit;
893 }
894
895 ssp->nchannels = nelements / LOMBUS_REGSPEC_SIZE;
896
897 ssp->attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
898 ssp->attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC;
899 ssp->attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
900
901 for (i = 0; i < ssp->nchannels; i++) {
902 retval = ddi_regs_map_setup(ssp->dip, i,
903 (caddr_t *)&ssp->channel[i].regs,
904 0, 0, &ssp->attr, &ssp->channel[i].handle);
905 if (retval != DDI_SUCCESS) {
906 BSCV_TRACE(ssp, 'A', "bscv_map_regs", "map failure"
907 " 0x%x on space %d", retval, i);
908
909 /* Rewind all current mappings - avoiding failed one */
910 i--;
911 for (; i >= 0; i--) {
912 ddi_regs_map_free(&ssp->channel[i].handle);
913 }
914
915 goto cleanup_exit;
916 }
917 }
918
919 return (DDI_SUCCESS);
920
921 cleanup_exit:
922 /*
923 * It is important to set nchannels to 0 even if, say, only one of
924 * the two required handles was mapped. If we cannot achieve our
925 * minimum config its not safe to do any IO; this keeps our failure
926 * mode handling simpler.
927 */
928 ssp->nchannels = 0;
929 return (DDI_FAILURE);
930 }
931
932 static void
933 bscv_unmap_regs(bscv_soft_state_t *ssp)
934 {
935 int i;
936
937 ASSERT(ssp);
938
939 for (i = 0; i < ssp->nchannels; i++) {
940 ddi_regs_map_free(&ssp->channel[i].handle);
941 }
942 }
943
944 /*
945 * Map logical services onto physical XBus channels.
946 */
947 static void
948 bscv_map_chan_logical_physical(bscv_soft_state_t *ssp)
949 {
950 ASSERT(ssp);
951
952 /*
953 * We can assert that there will always be at least two channels,
954 * to allow watchdog pats to be segregated from all other traffic.
955 */
956 chan_general = 0;
957 chan_wdogpat = 1;
958
959 /*
960 * By default move all other services onto the generic channel unless
961 * the hardware supports additional channels.
962 */
963
964 chan_cpusig = chan_eeprom = chan_prog = chan_general;
965
966 if (ssp->nchannels > 2)
967 chan_cpusig = 2;
968 if (ssp->nchannels > 3)
969 chan_eeprom = 3;
970 if (ssp->nchannels > 4)
971 chan_prog = 4;
972 }
973
974
975 /*
976 * function - bscv_full_stop
977 * description - gracefully shut the lom down during panic or reboot.
978 * Disables the watchdog and sets up serial event reporting.
979 * inputs - soft state pointer
980 * outputs - none
981 */
982 void
983 bscv_full_stop(bscv_soft_state_t *ssp)
984 {
985 uint8_t bits2set = 0;
986 uint8_t bits2clear = 0;
987 int obtained_lock;
988
989 BSCV_TRACE(ssp, 'W', "bscv_full_stop",
990 "turning off watchdog");
991
992 /*
993 * Obtain the softstate lock only if it is not already owned,
994 * as this function can be called from a High-level interrupt
995 * context. As a result, our thread cannot sleep.
996 * At end of function, our thread releases the lock only if
997 * it acquired the lock.
998 */
999 obtained_lock = (bscv_tryenter(ssp) != 0);
1000
1001 #if defined(__i386) || defined(__amd64)
1002 if (ddi_in_panic()) {
1003 bscv_inform_bsc(ssp, BSC_INFORM_PANIC);
1004 } else {
1005 bscv_inform_bsc(ssp, BSC_INFORM_OFFLINE);
1006 }
1007 #endif /* __i386 || __amd64 */
1008
1009 /* set serial event reporting */
1010 switch (ssp->serial_reporting) {
1011 case LOM_SER_EVENTS_ON:
1012 case LOM_SER_EVENTS_DEF:
1013 /* Make sure serial event reporting is on */
1014 bits2clear = EBUS_ALARM_NOEVENTS;
1015 break;
1016 case LOM_SER_EVENTS_OFF:
1017 /* Make sure serial event reporting is on */
1018 bits2set = EBUS_ALARM_NOEVENTS;
1019 break;
1020 default:
1021 break;
1022 }
1023 bscv_setclear8_volatile(ssp, chan_general,
1024 EBUS_IDX_ALARM, bits2set, bits2clear);
1025
1026 /* Do not free the lock if our thread did not obtain it. */
1027 if (obtained_lock != 0) {
1028 bscv_exit(ssp);
1029 }
1030 }
1031
1032 /*
1033 * LOM I/O routines.
1034 *
1035 * locking
1036 *
1037 * Two sets of routines are provided:
1038 * normal - must be called after acquiring an appropriate lock.
1039 * locked - perform all the locking required and return any error
1040 * code in the supplied 'res' argument. If there is no
1041 * error 'res' is not changed.
1042 * The locked routines are designed for use in ioctl commands where
1043 * only a single operation needs to be performed and the overhead of
1044 * locking and result checking adds significantly to code complexity.
1045 *
1046 * locking primitives
1047 *
1048 * bscv_enter() - acquires an I/O lock for the calling thread.
1049 * bscv_tryenter() - conditionally acquires an I/O lock for calling thread.
1050 * bscv_exit() - releases an I/O lock acquired by bscv_enter().
1051 * bscv_held() - used to assert ownership of an I/O lock.
1052 *
1053 * normal I/O routines
1054 *
1055 * Note bscv_{put|get}{16|32} routines are big-endian. This assumes that
1056 * the firmware works that way too.
1057 *
1058 * bscv_put8(), bscv_put16, bscv_put32 - write values to the LOM
1059 * and handle any retries if necessary.
1060 * 16 and 32 bit values are big-endian.
1061 * bscv_get8(), bscv_get16, bscv_get32 - read values from the LOM
1062 * and handle any retries if necessary.
1063 * 16 and 32 bit values are big-endian.
1064 * bscv_setclear8() - set or clear the specified bits in the register
1065 * at the supplied address.
1066 * bscv_setclear8_volatile() - set or clear the specified bits in the
1067 * register at the supplied address. If the lom reports
1068 * that the registers has changed since the last read
1069 * re-read and apply the set or clear to the new bits.
1070 * bscv_get8_cached() - Return a cached register value (addr < 0x80).
1071 * Does not access the hardware. A read of the hardware
1072 * automatically updates this cache.
1073 *
1074 * locked I/O routines
1075 *
1076 * bscv_get8_locked(), bscv_rep_get8_locked().
1077 *
1078 * Call the indicated function from above, but wrapping it with
1079 * bscv_enter()/bscv_exit().
1080 *
1081 *
1082 * Fault management
1083 *
1084 * LOM communications fault are grouped into three categories:
1085 * 1) Faulty - the LOM is not responding and no attempt to communicate
1086 * with it should be made.
1087 * 2) Transient fault - something which might recover after a retry
1088 * but which doesn't affect our ability to perform other
1089 * commands.
1090 * 3) Command error - an inappropriate command was executed. A retry
1091 * will not fix it but the command failed.
1092 *
1093 * The current implementation of the bscv driver is not very good at
1094 * noticing command errors due to the structure of the original code
1095 * that it is based on. It is possible to extend the driver to do this
1096 * and would probably involve having a concept of a "session error"
1097 * which is less severe than a fault but means that a sequence of
1098 * commands had some fault which cannot be recovered.
1099 *
1100 *
1101 * faults
1102 *
1103 * bscv_faulty() - returns B_TRUE if the LOM (communications) have been
1104 * declared faulty.
1105 * bscv_clear_fault() - marks the LOM as not faulty.
1106 * bscv_set_fault() - marks the LOM as being faulty.
1107 *
1108 * bscv_clear_fault and bscv_set_fault should generally not be called
1109 * directly.
1110 *
1111 * command errors/transient faults
1112 *
1113 * bscv_retcode() - returns the actual error code of the last operation.
1114 * bscv_should_retry() - determines if last operation may suceed if
1115 * retried.
1116 * bscv_locked_result() - Set the result of a locked register access.
1117 *
1118 * low level I/O primitives
1119 *
1120 * These are generally not called directly. These perform a single
1121 * access to the LOM device. They do not handle retries.
1122 *
1123 * bscv_put8_once()
1124 * bscv_get8_once()
1125 * bscv_probe() - perform a probe (NOP) operation to check out lom comms.
1126 * bscv_resync_comms() - resynchronise communications after a transient fault.
1127 */
1128
1129 static void
1130 bscv_enter(bscv_soft_state_t *ssp)
1131 {
1132 BSCV_TRACE(ssp, '@', "bscv_enter", "");
1133 mutex_enter(&ssp->cmd_mutex);
1134 ssp->had_session_error = B_FALSE;
1135 }
1136
1137 static int
1138 bscv_tryenter(bscv_soft_state_t *ssp)
1139 {
1140 int rv;
1141
1142 BSCV_TRACE(ssp, '@', "bscv_tryenter", "");
1143 if ((rv = mutex_tryenter(&ssp->cmd_mutex)) != 0) {
1144 ssp->had_session_error = B_FALSE;
1145 }
1146 return (rv);
1147 }
1148
1149 static void
1150 bscv_exit(bscv_soft_state_t *ssp)
1151 {
1152 mutex_exit(&ssp->cmd_mutex);
1153 BSCV_TRACE(ssp, '@', "bscv_exit", "");
1154 }
1155
1156 #ifdef DEBUG
1157 static int
1158 bscv_held(bscv_soft_state_t *ssp)
1159 {
1160 return (mutex_owned(&ssp->cmd_mutex));
1161 }
1162 #endif /* DEBUG */
1163
1164 static void
1165 bscv_put8(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, uint8_t val)
1166 {
1167 boolean_t needretry;
1168 int num_failures;
1169
1170 ASSERT(bscv_held(ssp));
1171
1172 if (bscv_faulty(ssp)) {
1173 return;
1174 }
1175
1176 BSCV_TRACE(ssp, '@', "bscv_put8",
1177 "addr 0x%x.%02x <= 0x%02x", addr >> 8, addr & 0xff, val);
1178
1179 for (num_failures = 0;
1180 num_failures < BSC_FAILURE_RETRY_LIMIT;
1181 num_failures++) {
1182 bscv_put8_once(ssp, chan, addr, val);
1183 needretry = bscv_should_retry(ssp);
1184 if (!needretry) {
1185 break;
1186 }
1187 }
1188 if (ssp->command_error != 0) {
1189 ssp->had_session_error = B_TRUE;
1190 }
1191
1192 if (needretry) {
1193 /* Failure - we ran out of retries */
1194 cmn_err(CE_WARN, "bscv_put8: addr 0x%x.%02x retried "
1195 "write %d times, giving up",
1196 addr >> 8, addr & 0xff, num_failures);
1197 bscv_set_fault(ssp);
1198 } else if (num_failures > 0) {
1199 BSCV_TRACE(ssp, 'R', "bscv_put8",
1200 "addr 0x%x.%02x retried write %d times, succeeded",
1201 addr >> 8, addr & 0xff, num_failures);
1202 }
1203 }
1204
1205 static void
1206 bscv_put16(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, uint16_t val)
1207 {
1208 ASSERT(bscv_held(ssp));
1209 BSCV_TRACE(ssp, '@', "bscv_put16",
1210 "addr 0x%x.%02x <= %04x", addr >> 8, addr & 0xff, val);
1211 bscv_put8(ssp, chan, addr, val >> 8);
1212 bscv_put8(ssp, chan, addr + 1, val & 0xff);
1213 }
1214
1215 static void
1216 bscv_put32(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, uint32_t val)
1217 {
1218 ASSERT(bscv_held(ssp));
1219 BSCV_TRACE(ssp, '@', "bscv_put32",
1220 "addr 0x%x.%02x <= %08x", addr >> 8, addr & 0xff, val);
1221 bscv_put8(ssp, chan, addr, (val >> 24) & 0xff);
1222 bscv_put8(ssp, chan, addr + 1, (val >> 16) & 0xff);
1223 bscv_put8(ssp, chan, addr + 2, (val >> 8) & 0xff);
1224 bscv_put8(ssp, chan, addr + 3, val & 0xff);
1225 }
1226
1227 static uint8_t
1228 bscv_get8(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr)
1229 {
1230 uint8_t retval;
1231 boolean_t needretry;
1232 int num_failures;
1233
1234 ASSERT(bscv_held(ssp));
1235
1236 if (bscv_faulty(ssp)) {
1237 return (0);
1238 }
1239
1240 for (num_failures = 0;
1241 num_failures < BSC_FAILURE_RETRY_LIMIT;
1242 num_failures++) {
1243 retval = bscv_get8_once(ssp, chan, addr);
1244 needretry = bscv_should_retry(ssp);
1245 if (!needretry) {
1246 break;
1247 }
1248 }
1249 if (ssp->command_error != 0) {
1250 ssp->had_session_error = B_TRUE;
1251 }
1252
1253 if (needretry) {
1254 /* Failure */
1255 cmn_err(CE_WARN, "bscv_get8: addr 0x%x.%02x retried "
1256 "read %d times, giving up",
1257 addr >> 8, addr & 0xff, num_failures);
1258 bscv_set_fault(ssp);
1259 } else if (num_failures > 0) {
1260 BSCV_TRACE(ssp, 'R', "bscv_get8",
1261 "addr 0x%x.%02x retried read %d times, succeeded",
1262 addr >> 8, addr & 0xff, num_failures);
1263 }
1264
1265 BSCV_TRACE(ssp, '@', "bscv_get8",
1266 "addr 0x%x.%02x => %02x", addr >> 8, addr & 0xff, retval);
1267 return (retval);
1268 }
1269
1270 static uint16_t
1271 bscv_get16(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr)
1272 {
1273 uint16_t retval;
1274
1275 ASSERT(bscv_held(ssp));
1276
1277 retval = bscv_get8(ssp, chan, addr) << 8;
1278 retval |= bscv_get8(ssp, chan, addr + 1);
1279
1280 BSCV_TRACE(ssp, '@', "bscv_get16",
1281 "addr 0x%x.%02x => %04x", addr >> 8, addr & 0xff, retval);
1282 return (retval);
1283 }
1284
1285 static uint32_t
1286 bscv_get32(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr)
1287 {
1288 uint32_t retval;
1289
1290 ASSERT(bscv_held(ssp));
1291
1292 retval = bscv_get8(ssp, chan, addr) << 24;
1293 retval |= bscv_get8(ssp, chan, addr + 1) << 16;
1294 retval |= bscv_get8(ssp, chan, addr + 2) << 8;
1295 retval |= bscv_get8(ssp, chan, addr + 3);
1296
1297 BSCV_TRACE(ssp, '@', "bscv_get32",
1298 "addr 0x%x.%02x => %08x", addr >> 8, addr & 0xff, retval);
1299 return (retval);
1300 }
1301
1302 static void
1303 bscv_setclear8(bscv_soft_state_t *ssp, int chan,
1304 bscv_addr_t addr, uint8_t set, uint8_t clear)
1305 {
1306 uint8_t val;
1307
1308 ASSERT(bscv_held(ssp));
1309 ASSERT(addr < BSC_ADDR_CACHE_LIMIT);
1310
1311 val = ssp->lom_regs[addr] | set;
1312 val &= ~clear;
1313
1314 BSCV_TRACE(ssp, '@', "bscv_setclear8",
1315 "addr 0x%x.%02x, set %02x, clear %02x => %02x",
1316 addr >> 8, addr & 0xff,
1317 set, clear, val);
1318
1319 bscv_put8(ssp, chan, addr, val);
1320 }
1321
1322 static void
1323 bscv_setclear8_volatile(bscv_soft_state_t *ssp, int chan,
1324 bscv_addr_t addr, uint8_t set, uint8_t clear)
1325 {
1326 uint8_t val;
1327 boolean_t needretry;
1328 int num_failures;
1329
1330 ASSERT(bscv_held(ssp));
1331 ASSERT(addr < BSC_ADDR_CACHE_LIMIT);
1332
1333 if (bscv_faulty(ssp)) {
1334 return;
1335 }
1336
1337 BSCV_TRACE(ssp, '@', "bscv_setclear8_volatile",
1338 "addr 0x%x.%02x => set %02x clear %02x",
1339 addr >> 8, addr & 0xff, set, clear);
1340
1341 val = bscv_get8_cached(ssp, addr);
1342 for (num_failures = 0;
1343 num_failures < BSC_FAILURE_RETRY_LIMIT;
1344 num_failures++) {
1345 val |= set;
1346 val &= ~clear;
1347 bscv_put8_once(ssp, chan, addr, val);
1348 if (ssp->command_error == EBUS_ERROR_STALEDATA) {
1349 /* Re-read the stale register from the lom */
1350 val = bscv_get8_once(ssp, chan, addr);
1351 needretry = 1;
1352 } else {
1353 needretry = bscv_should_retry(ssp);
1354 if (!needretry) {
1355 break;
1356 }
1357 }
1358 }
1359 if (ssp->command_error != 0) {
1360 ssp->had_session_error = B_TRUE;
1361 }
1362
1363 if (needretry) {
1364 /* Failure */
1365 cmn_err(CE_WARN, "bscv_setclear8_volatile: addr 0x%x.%02x "
1366 "retried write %d times, giving up",
1367 addr >> 8, addr & 0xff, num_failures);
1368 if (ssp->command_error != EBUS_ERROR_STALEDATA) {
1369 bscv_set_fault(ssp);
1370 }
1371 } else if (num_failures > 0) {
1372 BSCV_TRACE(ssp, 'R', "bscv_setclear8_volatile",
1373 "addr 0x%x.%02x retried write %d times, succeeded",
1374 addr >> 8, addr & 0xff, num_failures);
1375 }
1376 }
1377
1378 static void
1379 bscv_rep_rw8(bscv_soft_state_t *ssp, int chan, uint8_t *host_addr,
1380 bscv_addr_t dev_addr, size_t repcount, uint_t flags,
1381 boolean_t is_write)
1382 {
1383 size_t inc;
1384
1385 ASSERT(bscv_held(ssp));
1386
1387 inc = (flags & DDI_DEV_AUTOINCR) ? 1 : 0;
1388 for (; repcount--; dev_addr += inc) {
1389 if (flags & DDI_DEV_AUTOINCR) {
1390 if (is_write) {
1391 bscv_put8(ssp, chan, dev_addr, *host_addr++);
1392 } else {
1393 *host_addr++ = bscv_get8(ssp, chan, dev_addr);
1394 }
1395 } else {
1396 if (is_write) {
1397 bscv_put8_once(ssp, chan,
1398 dev_addr, *host_addr++);
1399 } else {
1400 *host_addr++ = bscv_get8_once(ssp, chan,
1401 dev_addr);
1402 }
1403 /* We need this because _once routines don't do it */
1404 if (ssp->command_error != 0) {
1405 ssp->had_session_error = B_TRUE;
1406 }
1407 }
1408 if (bscv_faulty(ssp) || bscv_session_error(ssp)) {
1409 /*
1410 * No retry here. If we were AUTOINCR then get/put
1411 * will have retried. For NO_AUTOINCR we cannot retry
1412 * because the data would be corrupted.
1413 */
1414 break;
1415 }
1416 }
1417 }
1418
1419 static uint8_t
1420 bscv_get8_cached(bscv_soft_state_t *ssp, bscv_addr_t addr)
1421 {
1422 ASSERT(addr < BSC_ADDR_CACHE_LIMIT);
1423 /* Can be called with or without the lock held */
1424
1425 return (ssp->lom_regs[addr]);
1426 }
1427
1428 static uint8_t
1429 bscv_get8_locked(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, int *res)
1430 {
1431 uint8_t retval;
1432
1433 ASSERT(addr < BSC_ADDR_CACHE_LIMIT);
1434 bscv_enter(ssp);
1435 retval = bscv_get8(ssp, chan, addr);
1436 bscv_locked_result(ssp, res);
1437 bscv_exit(ssp);
1438 BSCV_TRACE(ssp, '@', "bscv_get8_locked",
1439 "addr 0x%x.%02x => %02x", addr >> 8, addr & 0xff, retval);
1440 return (retval);
1441 }
1442
1443 static void
1444 bscv_rep_get8_locked(bscv_soft_state_t *ssp, int chan, uint8_t *host_addr,
1445 bscv_addr_t dev_addr, size_t repcount, uint_t flags, int *res)
1446 {
1447 bscv_enter(ssp);
1448 bscv_rep_rw8(ssp, chan, host_addr, dev_addr, repcount,
1449 flags, B_FALSE /* read */);
1450 bscv_locked_result(ssp, res);
1451 bscv_exit(ssp);
1452 }
1453
1454 static boolean_t
1455 bscv_faulty(bscv_soft_state_t *ssp)
1456 {
1457 ASSERT(bscv_held(ssp));
1458 return (ssp->had_fault);
1459 }
1460
1461 static void
1462 bscv_clear_fault(bscv_soft_state_t *ssp)
1463 {
1464 ASSERT(bscv_held(ssp));
1465 BSCV_TRACE(ssp, 'J', "bscv_clear_fault", "clearing fault flag");
1466 ssp->had_fault = B_FALSE;
1467 ssp->had_session_error = B_FALSE;
1468 }
1469
1470 static void
1471 bscv_set_fault(bscv_soft_state_t *ssp)
1472 {
1473 ASSERT(bscv_held(ssp));
1474 BSCV_TRACE(ssp, 'J', "bscv_set_fault", "setting fault flag");
1475 ssp->had_fault = B_TRUE;
1476 }
1477
1478 static boolean_t
1479 bscv_session_error(bscv_soft_state_t *ssp)
1480 {
1481 ASSERT(bscv_held(ssp));
1482 return (ssp->had_session_error);
1483 }
1484
1485 static int
1486 bscv_retcode(bscv_soft_state_t *ssp)
1487 {
1488 BSCV_TRACE(ssp, '@', "bscv_retcode",
1489 "code 0x%x", ssp->command_error);
1490 return (ssp->command_error);
1491 }
1492
1493 static int
1494 bscv_should_retry(bscv_soft_state_t *ssp)
1495 {
1496 if ((ssp->command_error == EBUS_ERROR_DEVICEFAIL) ||
1497 (ssp->command_error >= LOMBUS_ERR_BASE)) {
1498 /* This command is due to an I/O fault - retry might fix */
1499 return (1);
1500 } else {
1501 /*
1502 * The command itself was bad - there is no point in fixing
1503 * Note. Whatever happens we should know that if we were
1504 * doing EBUS_IDX_SELFTEST0..EBUS_IDX_SELFTEST7 and we
1505 * had 0x80 set then this is a test error not a retry
1506 * error.
1507 */
1508 return (0);
1509 }
1510 }
1511
1512 static void
1513 bscv_locked_result(bscv_soft_state_t *ssp, int *res)
1514 {
1515 if (bscv_faulty(ssp) || (bscv_retcode(ssp) != 0)) {
1516 *res = EIO;
1517 }
1518 }
1519
1520 static void
1521 bscv_put8_once(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, uint8_t val)
1522 {
1523 uint32_t fault;
1524
1525 ASSERT(bscv_held(ssp));
1526
1527 ssp->command_error = 0;
1528
1529 if (bscv_faulty(ssp)) {
1530 /* Bail out things are not working */
1531 return;
1532 } else if (ssp->nchannels == 0) {
1533 /* Didn't manage to map handles so ddi_{get,put}* broken */
1534 BSCV_TRACE(ssp, '@', "bscv_put8_once",
1535 "nchannels is 0x0 so cannot do IO");
1536 return;
1537 }
1538
1539 /* Clear any pending fault */
1540 ddi_put32(ssp->channel[chan].handle,
1541 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG), 0);
1542
1543 /* Do the access and get fault code - may take a long time */
1544 ddi_put8(ssp->channel[chan].handle,
1545 &ssp->channel[chan].regs[addr], val);
1546 fault = ddi_get32(ssp->channel[chan].handle,
1547 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG));
1548
1549 ssp->command_error = fault;
1550
1551 if (fault == 0) {
1552 /* Things were ok - update cache entry */
1553 if (addr < BSC_ADDR_CACHE_LIMIT) {
1554 /* Store cacheable entries */
1555 ssp->lom_regs[addr] = val;
1556 }
1557 } else if (fault >= LOMBUS_ERR_BASE) {
1558 /* lombus problem - do a resync session */
1559 cmn_err(CE_WARN, "!bscv_put8_once: Had comms fault "
1560 "for address 0x%x.%02x - data 0x%x, fault 0x%x",
1561 addr >> 8, addr & 0xff, val, fault);
1562 /* Attempt to resync with the lom */
1563 bscv_resync_comms(ssp, chan);
1564 /*
1565 * Note: we do not set fault status here. That
1566 * is done if our caller decides to give up talking to
1567 * the lom. The observant might notice that this means
1568 * that if we mend things on the last attempt we still
1569 * get the fault set - we just live with that!
1570 */
1571 }
1572
1573 BSCV_TRACE(ssp, '@', "bscv_put8_once",
1574 "addr 0x%x.%02x <= 0x%02x", addr >> 8, addr & 0xff, val);
1575 }
1576
1577 static uint8_t
1578 bscv_get8_once(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr)
1579 {
1580 uint8_t val;
1581 uint32_t fault;
1582
1583 ASSERT(bscv_held(ssp));
1584
1585 ssp->command_error = 0;
1586
1587 if (bscv_faulty(ssp)) {
1588 /* Bail out things are not working */
1589 return (0xff);
1590 } else if (ssp->nchannels == 0) {
1591 /* Didn't manage to map handles so ddi_{get,put}* broken */
1592 BSCV_TRACE(ssp, '@', "bscv_get8_once",
1593 "nchannels is 0x0 so cannot do IO");
1594 return (0xff);
1595 }
1596
1597 /* Clear any pending fault */
1598 ddi_put32(ssp->channel[chan].handle,
1599 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG), 0);
1600
1601 /* Do the access and get fault code - may take a long time */
1602 val = ddi_get8(ssp->channel[chan].handle,
1603 &ssp->channel[chan].regs[addr]);
1604 fault = ddi_get32(ssp->channel[chan].handle,
1605 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG));
1606 ssp->command_error = fault;
1607
1608 if (fault >= LOMBUS_ERR_BASE) {
1609 /* lombus problem - do a resync session */
1610 cmn_err(CE_WARN, "!bscv_get8_once: Had comms fault "
1611 "for address 0x%x.%02x - data 0x%x, fault 0x%x",
1612 addr >> 8, addr & 0xff, val, fault);
1613 /* Attempt to resync with the lom */
1614 bscv_resync_comms(ssp, chan);
1615 /*
1616 * Note: we do not set fault status here. That
1617 * is done if our caller decides to give up talking to
1618 * the lom. The observant might notice that this means
1619 * that if we mend things on the last attempt we still
1620 * get the fault set - we just live with that!
1621 */
1622 }
1623 /*
1624 * FIXME - should report error if you get
1625 * EBUS_ERROR_DEVICEFAIL reported from the BSC. That gets
1626 * logged as a failure in bscv_should_retry and may contribute
1627 * to a permanent failure. Reference issues seen by Mitac.
1628 */
1629
1630 if (!bscv_faulty(ssp)) {
1631 if (addr < BSC_ADDR_CACHE_LIMIT) {
1632 /* Store cacheable entries */
1633 ssp->lom_regs[addr] = val;
1634 }
1635 }
1636
1637 BSCV_TRACE(ssp, '@', "bscv_get8_once",
1638 "addr 0x%x.%02x => 0x%02x", addr >> 8, addr & 0xff, val);
1639 return (val);
1640 }
1641
1642 static uint32_t
1643 bscv_probe(bscv_soft_state_t *ssp, int chan, uint32_t *fault)
1644 {
1645 uint32_t async_reg;
1646
1647 if (ssp->nchannels == 0) {
1648 /*
1649 * Failed to map handles, so cannot do any IO. Set the
1650 * fault indicator and return a dummy value.
1651 */
1652 BSCV_TRACE(ssp, '@', "bscv_probe",
1653 "nchannels is 0x0 so cannot do any IO");
1654 *fault = LOMBUS_ERR_REG_NUM;
1655 return ((~(int8_t)0));
1656 }
1657
1658 /* Clear faults */
1659 ddi_put32(ssp->channel[chan].handle,
1660 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG), 0);
1661 /* Probe and Check faults */
1662 *fault = ddi_get32(ssp->channel[chan].handle,
1663 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_PROBE_REG));
1664 /* Read status */
1665 async_reg = ddi_get32(ssp->channel[chan].handle,
1666 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_ASYNC_REG));
1667
1668 BSCV_TRACE(ssp, '@', "bscv_probe",
1669 "async status 0x%x, fault 0x%x", async_reg, *fault);
1670 return (async_reg);
1671 }
1672
1673 static void
1674 bscv_resync_comms(bscv_soft_state_t *ssp, int chan)
1675 {
1676 int try;
1677 uint32_t command_error = ssp->command_error;
1678 uint32_t fault = 0;
1679
1680 if (ssp->nchannels == 0) {
1681 /*
1682 * Didn't manage to map handles so ddi_{get,put}* broken.
1683 * Therefore, there is no way to resync comms.
1684 */
1685 BSCV_TRACE(ssp, '@', "bscv_resync_comms",
1686 "nchannels is 0x0 so not possible to resync comms");
1687 return;
1688 }
1689 if (command_error >= LOMBUS_ERR_BASE &&
1690 command_error != LOMBUS_ERR_REG_NUM &&
1691 command_error != LOMBUS_ERR_REG_SIZE &&
1692 command_error != LOMBUS_ERR_TIMEOUT) {
1693 /* Resync here to make sure that the lom is talking */
1694 cmn_err(CE_WARN, "!bscv_resync_comms: "
1695 "Attempting comms resync after comms fault 0x%x",
1696 command_error);
1697 for (try = 1; try <= 8; try++) {
1698 /* Probe */
1699 fault = ddi_get32(ssp->channel[chan].handle,
1700 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0,
1701 LOMBUS_PROBE_REG));
1702
1703 if (fault == 0) {
1704 break;
1705 } else {
1706 cmn_err(CE_WARN, "!bscv_resync_comms: "
1707 "comms resync (probing) - try 0x%x "
1708 "had fault 0x%x", try, fault);
1709 }
1710 }
1711 if (fault != 0) {
1712 cmn_err(CE_WARN, "!bscv_resync_comms: "
1713 "Failed to resync comms - giving up");
1714 ssp->bad_resync++;
1715 } else {
1716 cmn_err(CE_WARN, "!bscv_resync_comms: "
1717 "resync comms after 0x%x tries", try);
1718 ssp->bad_resync = 0;
1719 }
1720 }
1721
1722 }
1723
1724
1725 /*
1726 * LOMLite configuration/event eeprom access routines
1727 *
1728 * bscv_window_setup() - Read/Sanity check the eeprom parameters.
1729 * This must be called prior to calling bscv_eerw().
1730 * bscv_eerw() - Read/write data from/to the eeprom.
1731 */
1732
1733 /*
1734 * function - bscv_window_setup
1735 * description - this routine reads the eeprom parameters and sanity
1736 * checks them to ensure that the lom is talking sense.
1737 * inputs - soft state ptr
1738 * outputs - B_TRUE if the eeprom is ok, B_FALSE if the eeprom is not OK.
1739 */
1740 static boolean_t
1741 bscv_window_setup(bscv_soft_state_t *ssp)
1742 {
1743 ASSERT(bscv_held(ssp));
1744
1745 if (ssp->eeinfo_valid) {
1746 /* Already have good cached values */
1747 return (ssp->eeinfo_valid);
1748 }
1749 ssp->eeprom_size =
1750 bscv_get8(ssp, chan_general, EBUS_IDX_EEPROM_SIZE_KB) * 1024;
1751 ssp->eventlog_start = bscv_get16(ssp, chan_general,
1752 EBUS_IDX_LOG_START_HI);
1753
1754 /*
1755 * The log does not run to the end of the EEPROM because it is a
1756 * logical partition. The last 8K partition is reserved for FRUID
1757 * usage.
1758 */
1759 ssp->eventlog_size = EBUS_LOG_END - ssp->eventlog_start;
1760
1761 BSCV_TRACE(ssp, 'I', "bscv_window_setup", "eeprom size 0x%x log_start"
1762 " 0x%x log_size 0x%x", ssp->eeprom_size, ssp->eventlog_start,
1763 ssp->eventlog_size);
1764
1765 if (bscv_faulty(ssp) || bscv_session_error(ssp)) {
1766 ssp->eeinfo_valid = B_FALSE;
1767 } else if ((ssp->eeprom_size == 0) ||
1768 (ssp->eventlog_start >= ssp->eeprom_size)) {
1769 /* Sanity check values */
1770 cmn_err(CE_WARN,
1771 "!bscv_window_setup: read invalid eeprom parameters");
1772 ssp->eeinfo_valid = B_FALSE;
1773 } else {
1774 ssp->eeinfo_valid = B_TRUE;
1775 }
1776
1777 BSCV_TRACE(ssp, 'I', "bscv_window_setup", "returning eeinfo_valid %s",
1778 ssp->eeinfo_valid ? "true" : "false");
1779 return (ssp->eeinfo_valid);
1780 }
1781
1782 /*
1783 * function - bscv_eerw
1784 * description - this routine reads/write data from/to the eeprom.
1785 * It takes care of setting the window on the eeprom correctly.
1786 * inputs - soft state ptr, eeprom offset, data buffer, size, read/write
1787 * outputs - B_TRUE if the eeprom is ok, B_FALSE if the eeprom is not OK.
1788 */
1789 static int
1790 bscv_eerw(bscv_soft_state_t *ssp, uint32_t eeoffset, uint8_t *buf,
1791 unsigned size, boolean_t is_write)
1792 {
1793 uint32_t blk_addr = eeoffset;
1794 unsigned remaining = size;
1795 uint8_t page_idx;
1796 uint8_t this_page;
1797 uint8_t blk_size;
1798 int res = 0;
1799
1800 while (remaining > 0) {
1801 page_idx = blk_addr & 0xff;
1802 if ((page_idx + remaining) > 0x100) {
1803 blk_size = 0x100 - page_idx;
1804 } else {
1805 blk_size = remaining;
1806 }
1807
1808 /* Select correct eeprom page */
1809 this_page = blk_addr >> 8;
1810 bscv_put8(ssp, chan_eeprom, EBUS_IDX_EEPROM_PAGESEL, this_page);
1811
1812 BSCV_TRACE(ssp, 'M', "lom_eerw",
1813 "%s data @0x%x.%02x, size 0x%x, 0x%x bytes remaining",
1814 is_write ? "writing" : "reading",
1815 this_page, page_idx, blk_size, remaining - blk_size);
1816
1817 bscv_rep_rw8(ssp, chan_eeprom,
1818 buf, BSCVA(EBUS_CMD_SPACE_EEPROM, page_idx),
1819 blk_size, DDI_DEV_AUTOINCR, is_write);
1820
1821 if (bscv_faulty(ssp) || bscv_session_error(ssp)) {
1822 res = EIO;
1823 break;
1824 }
1825
1826 remaining -= blk_size;
1827 blk_addr += blk_size;
1828 buf += blk_size;
1829 }
1830
1831 return (res);
1832 }
1833
1834 static boolean_t
1835 bscv_is_null_event(bscv_soft_state_t *ssp, lom_event_t *e)
1836 {
1837 ASSERT(e != NULL);
1838
1839 if (EVENT_DECODE_SUBSYS(e->ev_subsys) == EVENT_SUBSYS_NONE &&
1840 e->ev_event == EVENT_NONE) {
1841 /*
1842 * This marks a NULL event.
1843 */
1844 BSCV_TRACE(ssp, 'E', "bscv_is_null_event",
1845 "EVENT_SUBSYS_NONE/EVENT_NONE null event");
1846 return (B_TRUE);
1847 } else if (e->ev_subsys == 0xff && e->ev_event == 0xff) {
1848 /*
1849 * Under some circumstances, we've seen all 1s to represent
1850 * a manually cleared event log at the BSC prompt. Only
1851 * a test/diagnosis environment is likely to show this.
1852 */
1853 BSCV_TRACE(ssp, 'E', "bscv_is_null_event", "0xffff null event");
1854 return (B_TRUE);
1855 } else {
1856 /*
1857 * Not a NULL event.
1858 */
1859 BSCV_TRACE(ssp, 'E', "bscv_is_null_event", "returning False");
1860 return (B_FALSE);
1861 }
1862 }
1863
1864 /*
1865 * *********************************************************************
1866 * IOCTL Processing
1867 * *********************************************************************
1868 */
1869
1870 /*
1871 * function - bscv_ioctl
1872 * description - routine that acts as a high level manager for ioctls. It
1873 * calls the appropriate handler for ioctls on the alarm:mon and
1874 * alarm:ctl minor nodes respectively
1875 *
1876 * Unsupported ioctls (now deprecated)
1877 * LOMIOCALCTL
1878 * LOMIOCALSTATE
1879 * LOMIOCCLEARLOG
1880 * LOMIOCCTL
1881 * LOMIOCCTL2
1882 * LOMIOCDAEMON
1883 * LOMIOCDMON
1884 * LOMIOCDOGCTL, TSIOCDOGCTL
1885 * LOMIOCDOGPAT, TSIOCDOGPAT
1886 * LOMIOCDOGTIME, TSIOCDOGTIME
1887 * LOMIOCEVENTLOG
1888 * LOMIOCEVNT
1889 * LOMIOCGETMASK
1890 * LOMIOCMPROG
1891 * LOMIOCNBMON, TSIOCNBMON
1892 * LOMIOCSLEEP
1893 * LOMIOCUNLOCK, TSIOCUNLOCK
1894 * LOMIOCWTMON, TSIOCWTMON
1895 *
1896 * Supported ioctls
1897 * LOMIOCDOGSTATE, TSIOCDOGSTATE
1898 * LOMIOCPROG
1899 * LOMIOCPSUSTATE
1900 * LOMIOCFANSTATE
1901 * LOMIOCFLEDSTATE
1902 * LOMIOCINFO
1903 * LOMIOCMREAD
1904 * LOMIOCVOLTS
1905 * LOMIOCSTATS
1906 * LOMIOCTEMP
1907 * LOMIOCCONS
1908 * LOMIOCEVENTLOG2
1909 * LOMIOCINFO2
1910 * LOMIOCTEST
1911 * LOMIOCMPROG2
1912 * LOMIOCMREAD2
1913 *
1914 * inputs - device number, command, user space arg, filemode, user
1915 * credentials, return value
1916 * outputs - the return value propagated back by the lower level routines.
1917 */
1918
1919 /*ARGSUSED*/
1920 static int
1921 bscv_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cred, int *rvalp)
1922 {
1923 bscv_soft_state_t *ssp;
1924 int instance;
1925 int res = 0;
1926
1927 instance = DEVICETOINSTANCE(dev);
1928 ssp = ddi_get_soft_state(bscv_statep, instance);
1929 if (ssp == NULL) {
1930 return (ENXIO);
1931 }
1932
1933 /*
1934 * The Combined Switch and Service Processor takes care of configuration
1935 * and control. The CSSP tells the BSC chip about it; therefore the
1936 * bscv driver doesn't send such configuration and control to the BSC.
1937 * Additionally Watchdog configuration is no longer done from userland
1938 * lom.
1939 */
1940 switch (cmd) {
1941 case LOMIOCALCTL:
1942 case LOMIOCALSTATE:
1943 case LOMIOCCLEARLOG:
1944 case LOMIOCCTL:
1945 case LOMIOCCTL2:
1946 case LOMIOCDAEMON:
1947 case LOMIOCDMON:
1948 case LOMIOCDOGCTL:
1949 case LOMIOCDOGPAT:
1950 case LOMIOCDOGTIME:
1951 case LOMIOCEVENTLOG:
1952 case LOMIOCEVNT:
1953 case LOMIOCGETMASK:
1954 case LOMIOCMPROG:
1955 case LOMIOCNBMON:
1956 case LOMIOCSLEEP:
1957 case LOMIOCUNLOCK:
1958 case LOMIOCWTMON:
1959 return (ENOTSUP);
1960 }
1961
1962 /*
1963 * set the default result.
1964 */
1965
1966 *rvalp = 0;
1967
1968 if (ssp->cssp_prog) {
1969 return (ENXIO);
1970 } else if ((ssp->prog_mode_only || ssp->programming) &&
1971 cmd != LOMIOCPROG) {
1972 return (ENXIO);
1973 }
1974
1975 /*
1976 * Check that the caller has appropriate access permissions
1977 * (FWRITE set in mode) for those ioctls which change lom
1978 * state
1979 */
1980 if (!(mode & FWRITE)) {
1981 switch (cmd) {
1982 case LOMIOCMPROG2:
1983 case LOMIOCMREAD2:
1984 case LOMIOCPROG:
1985 case LOMIOCTEST:
1986 return (EACCES);
1987 /* NOTREACHED */
1988 default:
1989 /* Does not require write access */
1990 break;
1991 }
1992 }
1993
1994 switch (cmd) {
1995
1996 case LOMIOCDOGSTATE:
1997 res = bscv_ioc_dogstate(ssp, arg, mode);
1998 break;
1999
2000 case LOMIOCPROG:
2001 res = bscv_prog(ssp, arg, mode);
2002 break;
2003
2004 case LOMIOCPSUSTATE:
2005 res = bscv_ioc_psustate(ssp, arg, mode);
2006 break;
2007
2008 case LOMIOCFANSTATE:
2009 res = bscv_ioc_fanstate(ssp, arg, mode);
2010 break;
2011
2012 case LOMIOCFLEDSTATE:
2013 res = bscv_ioc_fledstate(ssp, arg, mode);
2014 break;
2015
2016 case LOMIOCLEDSTATE:
2017 res = bscv_ioc_ledstate(ssp, arg, mode);
2018 break;
2019
2020 case LOMIOCINFO:
2021 res = bscv_ioc_info(ssp, arg, mode);
2022 break;
2023
2024 case LOMIOCMREAD:
2025 res = bscv_ioc_mread(ssp, arg, mode);
2026 break;
2027
2028 case LOMIOCVOLTS:
2029 res = bscv_ioc_volts(ssp, arg, mode);
2030 break;
2031
2032 case LOMIOCSTATS:
2033 res = bscv_ioc_stats(ssp, arg, mode);
2034 break;
2035
2036 case LOMIOCTEMP:
2037 res = bscv_ioc_temp(ssp, arg, mode);
2038 break;
2039
2040 case LOMIOCCONS:
2041 res = bscv_ioc_cons(ssp, arg, mode);
2042 break;
2043
2044 case LOMIOCEVENTLOG2:
2045 res = bscv_ioc_eventlog2(ssp, arg, mode);
2046 break;
2047
2048 case LOMIOCINFO2:
2049 res = bscv_ioc_info2(ssp, arg, mode);
2050 break;
2051
2052 case LOMIOCTEST:
2053 res = bscv_ioc_test(ssp, arg, mode);
2054 break;
2055
2056 case LOMIOCMPROG2:
2057 res = bscv_ioc_mprog2(ssp, arg, mode);
2058 break;
2059
2060 case LOMIOCMREAD2:
2061 res = bscv_ioc_mread2(ssp, arg, mode);
2062 break;
2063
2064 default:
2065 BSCV_TRACE(ssp, 'I', "bscv_ioctl", "Invalid IOCTL 0x%x", cmd);
2066 res = EINVAL;
2067 }
2068 return (res);
2069 }
2070
2071 /*
2072 * LOMIOCDOGSTATE
2073 * TSIOCDOGSTATE - indicate whether the alarm watchdog and reset
2074 * circuitry is enabled or not.
2075 */
2076 static int
2077 bscv_ioc_dogstate(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2078 {
2079 lom_dogstate_t dogstate;
2080 uint8_t dogval;
2081 int res = 0;
2082
2083 dogval = bscv_get8_locked(ssp, chan_general, EBUS_IDX_WDOG_CTRL, &res);
2084 dogstate.dog_enable = (dogval & EBUS_WDOG_ENABLE) ? 1 : 0;
2085 dogstate.reset_enable = (dogval & EBUS_WDOG_RST) ? 1 : 0;
2086 dogstate.dog_timeout = bscv_get8_locked(ssp, chan_general,
2087 EBUS_IDX_WDOG_TIME, &res);
2088
2089 if ((res == 0) &&
2090 (ddi_copyout((caddr_t)&dogstate,
2091 (caddr_t)arg, sizeof (dogstate), mode) < 0)) {
2092 res = EFAULT;
2093 }
2094 return (res);
2095 }
2096
2097 /*
2098 * LOMIOCPSUSTATE - returns full information for 4 PSUs. All this
2099 * information is available from two bytes of LOMlite RAM, but if
2100 * on the first read it is noticed that two or more of the PSUs are
2101 * not present only 1 byte will be read subsequently.
2102 */
2103 static int
2104 bscv_ioc_psustate(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2105 {
2106 lom_psudata_t psudata;
2107 uint8_t psustat;
2108 int i;
2109 int res = 0;
2110
2111 for (i = 0; i < MAX_PSUS; i++) {
2112 psustat = bscv_get8_locked(ssp, chan_general,
2113 EBUS_IDX_PSU1_STAT + i, &res);
2114 psudata.fitted[i] = psustat & EBUS_PSU_PRESENT;
2115 psudata.output[i] = psustat & EBUS_PSU_OUTPUT;
2116 psudata.supplyb[i] = psustat & EBUS_PSU_INPUTB;
2117 psudata.supplya[i] = psustat & EBUS_PSU_INPUTA;
2118 psudata.standby[i] = psustat & EBUS_PSU_STANDBY;
2119 }
2120
2121 if (ddi_copyout((caddr_t)&psudata, (caddr_t)arg, sizeof (psudata),
2122 mode) < 0) {
2123 res = EFAULT;
2124 }
2125 return (res);
2126 }
2127
2128 /*
2129 * LOMIOCFANSTATE - returns full information including speed for 4
2130 * fans and the minimum and maximum operating speeds for each fan as
2131 * stored in the READ ONLY EEPROM data. As this EEPROM data is set
2132 * at manufacture time, this data should only be read by the driver
2133 * once and stored locally.
2134 */
2135 static int
2136 bscv_ioc_fanstate(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2137 {
2138 lom_fandata_t fandata;
2139 int numfans;
2140 int i;
2141 int res = 0;
2142
2143 bzero(&fandata, sizeof (lom_fandata_t));
2144 numfans = EBUS_CONFIG_NFAN_DEC(bscv_get8_locked(ssp,
2145 chan_general, EBUS_IDX_CONFIG, &res));
2146 for (i = 0; (i < numfans) && (res == 0); i++) {
2147 if (ssp->fanspeed[i] != LOM_FAN_NOT_PRESENT) {
2148 fandata.fitted[i] = 1;
2149 fandata.speed[i] = ssp->fanspeed[i];
2150 fandata.minspeed[i] = bscv_get8_cached(ssp,
2151 EBUS_IDX_FAN1_LOW + i);
2152 }
2153 }
2154
2155 if ((res == 0) &&
2156 (ddi_copyout((caddr_t)&fandata, (caddr_t)arg, sizeof (fandata),
2157 mode) < 0)) {
2158 res = EFAULT;
2159 }
2160 return (res);
2161 }
2162
2163 /*
2164 * LOMIOCFLEDSTATE - returns the state of the fault LED
2165 */
2166 static int
2167 bscv_ioc_fledstate(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2168 {
2169 lom_fled_info_t fled_info;
2170 uint8_t fledstate;
2171 int res = 0;
2172
2173 fledstate = bscv_get8_locked(ssp, chan_general, EBUS_IDX_ALARM, &res);
2174
2175 /* Decode of 0x0F is off and 0x00-0x07 is on. */
2176 if (EBUS_ALARM_LED_DEC(fledstate) == 0x0F) {
2177 fled_info.on = 0;
2178 } else {
2179 /* has +1 here - not 2 as in the info ioctl */
2180 fled_info.on = EBUS_ALARM_LED_DEC(fledstate) + 1;
2181 }
2182 if ((res == 0) &&
2183 (ddi_copyout((caddr_t)&fled_info, (caddr_t)arg,
2184 sizeof (fled_info), mode) < 0)) {
2185 res = EFAULT;
2186 }
2187 return (res);
2188 }
2189
2190 /*
2191 * LOMIOCLEDSTATE - returns the state of the requested LED
2192 */
2193 static int
2194 bscv_ioc_ledstate(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2195 {
2196 lom_led_state_t led_state;
2197 int fw_led_state;
2198 int res = 0;
2199
2200 /* copy in arguments supplied */
2201 if (ddi_copyin((caddr_t)arg, (caddr_t)&led_state,
2202 sizeof (lom_led_state_t), mode) < 0) {
2203 return (EFAULT);
2204 }
2205
2206 /*
2207 * check if led index is -1, if so set it to max value for
2208 * this implementation.
2209 */
2210 if (led_state.index == -1) {
2211 led_state.index = MAX_LED_ID;
2212 }
2213
2214 /* is the index in a valid range */
2215 if ((led_state.index > MAX_LED_ID) || (led_state.index < 0)) {
2216 led_state.state = LOM_LED_OUTOFRANGE;
2217 } else {
2218 /* read the relevant led info */
2219 fw_led_state = bscv_get8_locked(ssp, chan_general,
2220 EBUS_IDX_LED1_STATUS + led_state.index, &res);
2221
2222 /* set the state values accordingly */
2223 switch (fw_led_state) {
2224 case LOM_LED_STATE_OFF:
2225 led_state.state = LOM_LED_OFF;
2226 led_state.colour = LOM_LED_COLOUR_ANY;
2227 break;
2228 case LOM_LED_STATE_ON_STEADY:
2229 led_state.state = LOM_LED_ON;
2230 led_state.colour = LOM_LED_COLOUR_ANY;
2231 break;
2232 case LOM_LED_STATE_ON_FLASHING:
2233 case LOM_LED_STATE_ON_SLOWFLASH:
2234 led_state.state = LOM_LED_BLINKING;
2235 led_state.colour = LOM_LED_COLOUR_ANY;
2236 break;
2237 case LOM_LED_STATE_NOT_PRESENT:
2238 led_state.state = LOM_LED_NOT_IMPLEMENTED;
2239 led_state.colour = LOM_LED_COLOUR_NONE;
2240 break;
2241 case LOM_LED_STATE_INACCESSIBLE:
2242 case LOM_LED_STATE_STANDBY:
2243 default:
2244 led_state.state = LOM_LED_ACCESS_ERROR;
2245 led_state.colour = LOM_LED_COLOUR_NONE;
2246 break;
2247 }
2248
2249 /* set the label info */
2250 (void) strcpy(led_state.label,
2251 ssp->led_names[led_state.index]);
2252 }
2253
2254 /* copy out lom_state */
2255 if ((res == 0) &&
2256 (ddi_copyout((caddr_t)&led_state, (caddr_t)arg,
2257 sizeof (lom_led_state_t), mode) < 0)) {
2258 res = EFAULT;
2259 }
2260 return (res);
2261 }
2262
2263 /*
2264 * LOMIOCINFO - returns with a structure containing any information
2265 * stored on the LOMlite which a user should not need to access but
2266 * may be useful for diagnostic problems. The structure contains: the
2267 * serial escape character, alarm3 mode, version and checksum read from
2268 * RAM and the Product revision and ID read from EEPROM.
2269 */
2270 static int
2271 bscv_ioc_info(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2272 {
2273 lom_info_t info;
2274 int i;
2275 uint16_t csum;
2276 int res = 0;
2277
2278 info.ser_char = bscv_get8_locked(ssp, chan_general, EBUS_IDX_ESCAPE,
2279 &res);
2280 info.a3mode = WATCHDOG;
2281 info.fver = bscv_get8_locked(ssp, chan_general, EBUS_IDX_FW_REV, &res);
2282 csum = bscv_get8_locked(ssp, chan_general, EBUS_IDX_CHECK_HI, &res)
2283 << 8;
2284 csum |= bscv_get8_locked(ssp, chan_general, EBUS_IDX_CHECK_LO, &res);
2285 info.fchksum = csum;
2286 info.prod_rev = bscv_get8_locked(ssp, chan_general, EBUS_IDX_MODEL_REV,
2287 &res);
2288 for (i = 0; i < sizeof (info.prod_id); i++) {
2289 info.prod_id[i] = bscv_get8_locked(ssp,
2290 chan_general, EBUS_IDX_MODEL_ID1 + i, &res);
2291 }
2292 if (bscv_get8_locked(ssp, chan_general, EBUS_IDX_ALARM, &res) &
2293 EBUS_ALARM_NOEVENTS) {
2294 info.events = OFF;
2295 } else {
2296 info.events = ON;
2297 }
2298
2299 if ((res == 0) &&
2300 (ddi_copyout((caddr_t)&info, (caddr_t)arg, sizeof (info),
2301 mode) < 0)) {
2302 res = EFAULT;
2303 }
2304 return (res);
2305 }
2306
2307 /*
2308 * LOMIOCMREAD - used to query the LOMlite configuration parameters
2309 */
2310 static int
2311 bscv_ioc_mread(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2312 {
2313 lom_mprog_t mprog;
2314 int i;
2315 int fanz;
2316 int res = 0;
2317
2318 for (i = 0; i < sizeof (mprog.mod_id); i++) {
2319 mprog.mod_id[i] = bscv_get8_locked(ssp, chan_general,
2320 EBUS_IDX_MODEL_ID1 + i, &res);
2321 }
2322 mprog.mod_rev = bscv_get8_locked(ssp, chan_general, EBUS_IDX_MODEL_REV,
2323 &res);
2324 mprog.config = bscv_get8_locked(ssp, chan_general, EBUS_IDX_CONFIG,
2325 &res);
2326
2327 /* Read the fan calibration values */
2328 fanz = sizeof (mprog.fanhz) / sizeof (mprog.fanhz[0]);
2329 for (i = 0; i < fanz; i++) {
2330 mprog.fanhz[i] = bscv_get8_cached(ssp,
2331 EBUS_IDX_FAN1_CAL + i);
2332 mprog.fanmin[i] = bscv_get8_cached(ssp,
2333 EBUS_IDX_FAN1_LOW + i);
2334 }
2335
2336 if ((res == 0) &&
2337 (ddi_copyout((caddr_t)&mprog, (caddr_t)arg, sizeof (mprog),
2338 mode) < 0)) {
2339 res = EFAULT;
2340 }
2341 return (res);
2342 }
2343
2344 /*
2345 * LOMIOCVOLTS
2346 */
2347 static int
2348 bscv_ioc_volts(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2349 {
2350 int i;
2351 uint16_t supply;
2352 int res = 0;
2353
2354 supply = (bscv_get8_locked(ssp, chan_general, EBUS_IDX_SUPPLY_HI, &res)
2355 << 8) | bscv_get8_locked(ssp, chan_general, EBUS_IDX_SUPPLY_LO,
2356 &res);
2357
2358 for (i = 0; i < ssp->volts.num; i++) {
2359 ssp->volts.status[i] = (supply >> i) & 1;
2360 }
2361
2362 if ((res == 0) &&
2363 (ddi_copyout((caddr_t)&ssp->volts, (caddr_t)arg,
2364 sizeof (ssp->volts), mode) < 0)) {
2365 res = EFAULT;
2366 }
2367 return (res);
2368 }
2369
2370 /*
2371 * LOMIOCSTATS
2372 */
2373 static int
2374 bscv_ioc_stats(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2375 {
2376 int i;
2377 uint8_t status;
2378 int res = 0;
2379
2380 status = bscv_get8_locked(ssp, chan_general, EBUS_IDX_CBREAK_STATUS,
2381 &res);
2382 for (i = 0; i < ssp->sflags.num; i++) {
2383 ssp->sflags.status[i] = (int)((status >> i) & 1);
2384 }
2385
2386 if ((res == 0) &&
2387 (ddi_copyout((caddr_t)&ssp->sflags, (caddr_t)arg,
2388 sizeof (ssp->sflags), mode) < 0)) {
2389 res = EFAULT;
2390 }
2391 return (res);
2392 }
2393
2394 /*
2395 * LOMIOCTEMP
2396 */
2397 static int
2398 bscv_ioc_temp(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2399 {
2400 int i;
2401 int idx;
2402 uint8_t status_ov;
2403 lom_temp_t temps;
2404 int res = 0;
2405
2406 bzero(&temps, sizeof (temps));
2407 idx = 0;
2408 for (i = 0; i < ssp->temps.num; i++) {
2409 if (ssp->temps.temp[i] != LOM_TEMP_STATE_NOT_PRESENT) {
2410 temps.temp[idx] = ssp->temps.temp[i];
2411 bcopy(ssp->temps.name[i], temps.name[idx],
2412 sizeof (temps.name[idx]));
2413 temps.warning[idx] = ssp->temps.warning[i];
2414 temps.shutdown[idx] = ssp->temps.shutdown[i];
2415 idx++;
2416 }
2417 }
2418 temps.num = idx;
2419
2420 bcopy(ssp->temps.name_ov, temps.name_ov, sizeof (temps.name_ov));
2421 temps.num_ov = ssp->temps.num_ov;
2422 status_ov = bscv_get8_locked(ssp, chan_general, EBUS_IDX_OTEMP_STATUS,
2423 &res);
2424 for (i = 0; i < ssp->temps.num_ov; i++) {
2425 ssp->temps.status_ov[i] = (status_ov >> i) & 1;
2426 }
2427
2428 if ((res == 0) &&
2429 (ddi_copyout((caddr_t)&temps, (caddr_t)arg, sizeof (temps),
2430 mode) < 0)) {
2431 res = EFAULT;
2432 }
2433 return (res);
2434 }
2435
2436 /*
2437 * LOMIOCCONS
2438 */
2439 static int
2440 bscv_ioc_cons(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2441 {
2442 lom_cbuf_t cbuf;
2443 int datasize;
2444 int res = 0;
2445
2446 bzero(&cbuf, sizeof (cbuf));
2447 datasize = EBUS_IDX1_CONS_BUF_END - EBUS_IDX1_CONS_BUF_START + 1;
2448 /* Ensure that we do not overfill cbuf and that it is NUL terminated */
2449 if (datasize > (sizeof (cbuf) - 1)) {
2450 datasize = sizeof (cbuf) - 1;
2451 }
2452 bscv_rep_get8_locked(ssp, chan_general, (uint8_t *)cbuf.lrbuf,
2453 BSCVA(EBUS_CMD_SPACE1, (EBUS_IDX1_CONS_BUF_END - datasize + 1)),
2454 datasize, DDI_DEV_AUTOINCR, &res);
2455 /* This is always within the array due to the checks above */
2456 cbuf.lrbuf[datasize] = '\0';
2457
2458 if ((res == 0) &&
2459 (ddi_copyout((caddr_t)&cbuf, (caddr_t)arg, sizeof (cbuf),
2460 mode) < 0)) {
2461 res = EFAULT;
2462 }
2463 return (res);
2464 }
2465
2466 /*
2467 * LOMIOCEVENTLOG2
2468 */
2469 static int
2470 bscv_ioc_eventlog2(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2471 {
2472 lom_eventlog2_t *eventlog2;
2473 int events_recorded;
2474 int level;
2475 uint16_t next_offset;
2476 lom_event_t event;
2477 int res = 0;
2478
2479 eventlog2 = (lom_eventlog2_t *)kmem_zalloc(sizeof (*eventlog2),
2480 KM_SLEEP);
2481
2482 /*
2483 * First get number of events and level requested.
2484 */
2485
2486 if (ddi_copyin((caddr_t)arg, (caddr_t)eventlog2,
2487 sizeof (lom_eventlog2_t), mode) < 0) {
2488 kmem_free((void *)eventlog2, sizeof (*eventlog2));
2489 return (EFAULT);
2490 }
2491
2492 bscv_enter(ssp);
2493
2494 /*
2495 * OK we have full private access to the LOM now so loop
2496 * over the eventlog addr spaces until we get the required
2497 * number of events.
2498 */
2499
2500 if (!bscv_window_setup(ssp)) {
2501 res = EIO;
2502 bscv_exit(ssp);
2503 kmem_free((void *)eventlog2, sizeof (*eventlog2));
2504 return (res);
2505 }
2506
2507 /*
2508 * Read count, next event ptr MSB,LSB. Note a read of count
2509 * is necessary to latch values for the next event ptr
2510 */
2511 (void) bscv_get8(ssp, chan_general, EBUS_IDX_UNREAD_EVENTS);
2512 next_offset = bscv_get16(ssp, chan_general, EBUS_IDX_LOG_PTR_HI);
2513 BSCV_TRACE(ssp, 'I', "bscv_ioc_eventlog2", "log_ptr_hi 0x%x",
2514 next_offset);
2515
2516 events_recorded = 0;
2517
2518 while (events_recorded < eventlog2->num) {
2519 /*
2520 * Working backwards - read an event at a time.
2521 * next_offset is one event on from where we want to be!
2522 * Decrement next_offset and maybe wrap to the end of the
2523 * buffer.
2524 * Note the unsigned arithmetic, so check values first!
2525 */
2526 if (next_offset <= ssp->eventlog_start) {
2527 /* Wrap to the end of the buffer */
2528 next_offset = ssp->eventlog_start + ssp->eventlog_size;
2529 BSCV_TRACE(ssp, 'I', "bscv_ioc_eventlog2", "wrapping"
2530 " around to end of buffer; next_offset 0x%x",
2531 next_offset);
2532 }
2533 next_offset -= sizeof (event);
2534
2535 if (bscv_eerw(ssp, next_offset, (uint8_t *)&event,
2536 sizeof (event), B_FALSE /* read */) != 0) {
2537 /* Fault reading data - stop */
2538 BSCV_TRACE(ssp, 'I', "bscv_ioc_eventlog2", "read"
2539 " failure for offset 0x%x", next_offset);
2540 res = EIO;
2541 break;
2542 }
2543
2544 if (bscv_is_null_event(ssp, &event)) {
2545 /*
2546 * No more events in this log so give up.
2547 */
2548 BSCV_TRACE(ssp, 'I', "bscv_ioc_eventlog2", "no more"
2549 " events left at offset 0x%x", next_offset);
2550 break;
2551 }
2552
2553 /*
2554 * Are we interested in this event
2555 */
2556
2557 level = bscv_level_of_event(&event);
2558 if (level <= eventlog2->level) {
2559 /* Arggh why the funny byte ordering 3, 2, 0, 1 */
2560 eventlog2->code[events_recorded] =
2561 ((unsigned)event.ev_event |
2562 ((unsigned)event.ev_subsys << 8) |
2563 ((unsigned)event.ev_resource << 16) |
2564 ((unsigned)event.ev_detail << 24));
2565
2566 eventlog2->time[events_recorded] =
2567 ((unsigned)event.ev_data[0] |
2568 ((unsigned)event.ev_data[1] << 8) |
2569 ((unsigned)event.ev_data[3] << 16) |
2570 ((unsigned)event.ev_data[2] << 24));
2571
2572 bscv_build_eventstring(ssp,
2573 &event, eventlog2->string[events_recorded],
2574 eventlog2->string[events_recorded] +
2575 sizeof (eventlog2->string[events_recorded]));
2576 events_recorded++;
2577 }
2578 }
2579
2580 eventlog2->num = events_recorded;
2581
2582 bscv_exit(ssp);
2583
2584 if ((res == 0) &&
2585 (ddi_copyout((caddr_t)eventlog2, (caddr_t)arg,
2586 sizeof (lom_eventlog2_t), mode) < 0)) {
2587 res = EFAULT;
2588 }
2589
2590 kmem_free((void *)eventlog2, sizeof (lom_eventlog2_t));
2591 return (res);
2592 }
2593
2594 /*
2595 * LOMIOCINFO2
2596 */
2597 static int
2598 bscv_ioc_info2(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2599 {
2600 lom2_info_t info2;
2601 int i;
2602 uint16_t csum;
2603 int res = 0;
2604
2605 bzero(&info2, sizeof (info2));
2606
2607 (void) strncpy(info2.escape_chars, ssp->escape_chars,
2608 sizeof (info2.escape_chars));
2609 info2.serial_events = ssp->reporting_level | ssp->serial_reporting;
2610 info2.a3mode = WATCHDOG;
2611
2612 info2.fver = bscv_get8_locked(ssp, chan_general, EBUS_IDX_FW_REV, &res);
2613 csum = bscv_get8_locked(ssp, chan_general, EBUS_IDX_CHECK_HI, &res)
2614 << 8;
2615 csum |= bscv_get8_locked(ssp, chan_general, EBUS_IDX_CHECK_LO, &res);
2616 info2.fchksum = csum;
2617 info2.prod_rev = bscv_get8_locked(ssp, chan_general,
2618 EBUS_IDX_MODEL_REV, &res);
2619 for (i = 0; i < sizeof (info2.prod_id); i++) {
2620 info2.prod_id[i] = bscv_get8_locked(ssp, chan_general,
2621 EBUS_IDX_MODEL_ID1 + i, &res);
2622 }
2623 info2.serial_config = bscv_get8_locked(ssp, chan_general,
2624 EBUS_IDX_SER_TIMEOUT, &res);
2625 if (bscv_get8_locked(ssp, chan_general, EBUS_IDX_CONFIG_MISC, &res) &
2626 EBUS_CONFIG_MISC_SECURITY_ENABLED) {
2627 info2.serial_config |= LOM_SER_SECURITY;
2628 }
2629 if (bscv_get8_locked(ssp, chan_general, EBUS_IDX_CONFIG_MISC, &res) &
2630 EBUS_CONFIG_MISC_AUTO_CONSOLE) {
2631 info2.serial_config |= LOM_SER_RETURN;
2632 }
2633 if (bscv_get8_locked(ssp, chan_general, EBUS_IDX_WDOG_CTRL, &res) &
2634 EBUS_WDOG_BREAK_DISABLE) {
2635 info2.serial_config |= LOM_DISABLE_WDOG_BREAK;
2636 }
2637 info2.baud_rate = bscv_get8_locked(ssp, chan_general,
2638 EBUS_IDX_SER_BAUD, &res);
2639 info2.serial_hw_config =
2640 ((int)bscv_get8_locked(ssp, chan_general,
2641 EBUS_IDX_SER_CHARMODE, &res) |
2642 ((int)bscv_get8_locked(ssp, chan_general,
2643 EBUS_IDX_SER_FLOWCTL, &res) << 8) |
2644 ((int)bscv_get8_locked(ssp, chan_general,
2645 EBUS_IDX_SER_MODEMTYPE, &res) << 16));
2646
2647 /*
2648 * There is no phone home support on the blade platform. We hardcode
2649 * FALSE and NUL for config and script respectively.
2650 */
2651 info2.phone_home_config = B_FALSE;
2652 info2.phone_home_script[0] = '\0';
2653
2654 for (i = 0; i < ssp->num_fans; i++) {
2655 (void) strcpy(info2.fan_names[i], ssp->fan_names[i]);
2656 }
2657
2658 if ((res == 0) &&
2659 (ddi_copyout((caddr_t)&info2, (caddr_t)arg, sizeof (info2),
2660 mode) < 0)) {
2661 res = EFAULT;
2662 }
2663 return (res);
2664 }
2665
2666 /*
2667 * LOMIOCTEST
2668 */
2669 static int
2670 bscv_ioc_test(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2671 {
2672 uint32_t test;
2673 uint8_t testnum;
2674 uint8_t testarg;
2675 int res = 0;
2676
2677 if (ddi_copyin((caddr_t)arg, (caddr_t)&test, sizeof (test),
2678 mode) < 0) {
2679 return (EFAULT);
2680 }
2681
2682 /*
2683 * Extract num iterations.
2684 */
2685
2686 testarg = (test & 0xff00) >> 8;
2687 testnum = test & 0xff;
2688
2689 BSCV_TRACE(ssp, 'F', "bscv_ioc_test",
2690 "LOMIOCTEST data 0x%x (test 0x%x, arg 0x%x)",
2691 test, (EBUS_IDX_SELFTEST0 + testnum), testarg);
2692
2693 switch (testnum + EBUS_IDX_SELFTEST0) {
2694 default:
2695 /* Invalid test */
2696 res = EINVAL;
2697 break;
2698
2699 case EBUS_IDX_SELFTEST0: /* power on self-test result */
2700 case EBUS_IDX_SELFTEST1: /* not used currently */
2701 case EBUS_IDX_SELFTEST2: /* not used currently */
2702 case EBUS_IDX_SELFTEST3: /* not used currently */
2703 case EBUS_IDX_SELFTEST4: /* not used currently */
2704 case EBUS_IDX_SELFTEST5: /* not used currently */
2705 case EBUS_IDX_SELFTEST6: /* LED self-test */
2706 case EBUS_IDX_SELFTEST7: /* platform-specific tests */
2707 /* Run the test */
2708
2709 /* Stop other things and then run the test */
2710 bscv_enter(ssp);
2711
2712 /*
2713 * Then we simply write the argument to the relevant register
2714 * and wait for the return code.
2715 */
2716 bscv_put8(ssp, chan_general,
2717 EBUS_IDX_SELFTEST0 + testnum, testarg);
2718 if (bscv_faulty(ssp)) {
2719 res = EIO;
2720 } else {
2721 /* Get hold of the SunVTS error code */
2722 test = bscv_retcode(ssp);
2723 }
2724
2725 bscv_exit(ssp);
2726 break;
2727 }
2728
2729 BSCV_TRACE(ssp, 'F', "bscv_ioc_test",
2730 "LOMIOCTEST status 0x%x, res 0x%x", test, res);
2731 if ((res == 0) &&
2732 (ddi_copyout((caddr_t)&test, (caddr_t)arg, sizeof (test),
2733 mode) < 0)) {
2734 res = EFAULT;
2735 }
2736 return (res);
2737 }
2738
2739 /*
2740 * LOMIOCMPROG2
2741 */
2742 static int
2743 bscv_ioc_mprog2(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2744 {
2745 lom2_mprog_t mprog2;
2746 uint32_t base_addr;
2747 uint32_t data_size;
2748 uint32_t eeprom_size;
2749 int res = 0;
2750
2751 if (ddi_copyin((caddr_t)arg, (caddr_t)&mprog2, sizeof (mprog2),
2752 mode) < 0) {
2753 return (EFAULT);
2754 }
2755
2756 /*
2757 * Note that originally this was accessed as 255 byte pages
2758 * in address spaces 240-255. We have to emulate this behaviour.
2759 */
2760 if ((mprog2.addr_space < 240) || (mprog2.addr_space > 255)) {
2761 return (EINVAL);
2762 }
2763
2764 bscv_enter(ssp);
2765
2766 /* Calculate required data location */
2767 data_size = 255;
2768 base_addr = (mprog2.addr_space - 240) * data_size;
2769
2770 eeprom_size = bscv_get8(ssp, chan_general, EBUS_IDX_EEPROM_SIZE_KB) *
2771 1024;
2772
2773 if (bscv_faulty(ssp)) {
2774 bscv_exit(ssp);
2775 return (EIO);
2776 } else if ((base_addr + data_size) > eeprom_size) {
2777 BSCV_TRACE(ssp, 'M', "bscv_ioc_mprog2",
2778 "Request extends past end of eeprom");
2779 bscv_exit(ssp);
2780 return (ENXIO);
2781 }
2782
2783 bscv_put8(ssp, chan_general, EBUS_IDX_CMD_RES, EBUS_CMD_UNLOCK1);
2784 if (bscv_faulty(ssp)) {
2785 BSCV_TRACE(ssp, 'M', "bscv_ioc_mprog2", "ML1 Write failed");
2786 bscv_exit(ssp);
2787 return (EIO);
2788 }
2789
2790 bscv_put8(ssp, chan_general, EBUS_IDX_CMD_RES, EBUS_CMD_UNLOCK2);
2791 if (bscv_faulty(ssp)) {
2792 BSCV_TRACE(ssp, 'M', "bscv_ioc_mprog2", "ML2 Write failed");
2793 bscv_exit(ssp);
2794 return (EIO);
2795 }
2796
2797 if (bscv_eerw(ssp, base_addr, &mprog2.data[0],
2798 data_size, B_TRUE /* write */) != 0) {
2799 res = EIO;
2800 }
2801
2802 /* Read a probe key to release the lock. */
2803 (void) bscv_get8(ssp, chan_general, EBUS_IDX_PROBEAA);
2804
2805 if (bscv_faulty(ssp)) {
2806 res = EIO;
2807 }
2808 bscv_exit(ssp);
2809
2810 return (res);
2811 }
2812
2813 /*
2814 * LOMIOCMREAD2
2815 */
2816 static int
2817 bscv_ioc_mread2(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2818 {
2819 lom2_mprog_t mprog2;
2820 uint32_t base_addr;
2821 uint32_t data_size;
2822 uint32_t eeprom_size;
2823 int res = 0;
2824
2825 if (ddi_copyin((caddr_t)arg, (caddr_t)&mprog2, sizeof (mprog2),
2826 mode) < 0) {
2827 return (EFAULT);
2828 }
2829
2830 /*
2831 * Need to stop the queue and then just read
2832 * the bytes blind to the relevant addresses.
2833 * Note that originally this was accessed as 255 byte pages
2834 * in address spaces 240-255. We have to emulate this behaviour.
2835 */
2836 if ((mprog2.addr_space < 240) || (mprog2.addr_space > 255)) {
2837 return (EINVAL);
2838 }
2839
2840 bscv_enter(ssp);
2841
2842 /* Calculate required data location */
2843 data_size = 255;
2844 base_addr = (mprog2.addr_space - 240) * data_size;
2845 eeprom_size = bscv_get8(ssp, chan_general, EBUS_IDX_EEPROM_SIZE_KB) *
2846 1024;
2847
2848 if (bscv_faulty(ssp)) {
2849 bscv_exit(ssp);
2850 return (EIO);
2851 } else if ((base_addr + data_size) > eeprom_size) {
2852 BSCV_TRACE(ssp, 'M', "bscv_ioc_mread2",
2853 "Request extends past end of eeprom");
2854 bscv_exit(ssp);
2855 return (ENXIO);
2856 }
2857
2858 if (bscv_eerw(ssp, base_addr, &mprog2.data[0],
2859 data_size, B_FALSE /* read */) != 0) {
2860 res = EIO;
2861 }
2862
2863 if (bscv_faulty(ssp)) {
2864 res = EIO;
2865 }
2866 bscv_exit(ssp);
2867
2868 if ((res == 0) &&
2869 (ddi_copyout((caddr_t)&mprog2, (caddr_t)arg, sizeof (mprog2),
2870 mode) < 0)) {
2871 res = EFAULT;
2872 }
2873 return (res);
2874 }
2875
2876 static void
2877 bscv_get_state_changes(bscv_soft_state_t *ssp)
2878 {
2879 int i = STATUS_READ_LIMIT;
2880 uint8_t change;
2881 uint8_t detail;
2882
2883 ASSERT(bscv_held(ssp));
2884
2885 while (i-- && !ssp->cssp_prog) {
2886 /* Are there any changes to process? */
2887 change = bscv_get8(ssp, chan_general, EBUS_IDX_STATE_CHNG);
2888 change &= EBUS_STATE_MASK;
2889 if (!change)
2890 break;
2891
2892 /* Clarify the pending change */
2893 detail = bscv_get8(ssp, chan_general, EBUS_IDX_EVENT_DETAIL);
2894
2895 bscv_status(ssp, change, detail);
2896 }
2897
2898 BSCV_TRACE(ssp, 'D', "bscv_get_state_changes",
2899 "loop index %d ssp->cssp_prog 0x%x", i, ssp->cssp_prog);
2900 }
2901
2902 /*
2903 * *********************************************************************
2904 * Event Processing
2905 * *********************************************************************
2906 */
2907
2908 /*
2909 * function - bscv_event_daemon
2910 * description - Perform periodic lom tasks in a separate thread.
2911 * inputs - LOM soft state structure pointer
2912 * outputs - none.
2913 */
2914 static void
2915 bscv_event_daemon(void *arg)
2916 {
2917 bscv_soft_state_t *ssp = (void *)arg;
2918 boolean_t do_events;
2919 boolean_t do_status;
2920 boolean_t do_nodename;
2921 boolean_t do_watchdog;
2922 uint32_t async_reg;
2923 uint32_t fault;
2924 clock_t poll_period = BSC_EVENT_POLL_NORMAL;
2925 int fault_cnt = 0;
2926
2927 BSCV_TRACE(ssp, 'D', "bscv_event_daemon",
2928 "bscv_event_daemon: started");
2929
2930 /* Acquire task daemon lock. */
2931 mutex_enter(&ssp->task_mu);
2932
2933 ssp->task_flags |= TASK_ALIVE_FLG;
2934
2935 for (;;) {
2936 if ((ssp->task_flags & TASK_STOP_FLG) != 0) {
2937 /* Stop request seen - terminate */
2938 break;
2939 }
2940 if ((ssp->task_flags & TASK_PAUSE_FLG) == 0) {
2941 /* Poll for events reported to the nexus */
2942 mutex_exit(&ssp->task_mu);
2943 /* Probe and Check faults */
2944 bscv_enter(ssp);
2945 async_reg = bscv_probe(ssp, chan_general, &fault);
2946 BSCV_TRACE(ssp, 'D', "bscv_event_daemon",
2947 "process event: async_reg 0x%x, fault 0x%x",
2948 async_reg, fault);
2949
2950 if (!fault) {
2951 /* Treat non-fault conditions */
2952
2953 if (ssp->cssp_prog || ssp->prog_mode_only) {
2954 /*
2955 * The BSC has become available again.
2956 */
2957 fault_cnt = 0;
2958 ssp->cssp_prog = B_FALSE;
2959 ssp->prog_mode_only = B_FALSE;
2960 (void) bscv_attach_common(ssp);
2961 } else if (fault_cnt > 0) {
2962 /* Previous fault has cleared */
2963 bscv_clear_fault(ssp);
2964 fault_cnt = 0;
2965 cmn_err(CE_WARN,
2966 "!bscv_event_daemon previous fault "
2967 "cleared.");
2968 } else if (bscv_faulty(ssp)) {
2969 /* Previous fault has cleared */
2970 bscv_clear_fault(ssp);
2971 /* Sleep to avoid busy waiting */
2972 ssp->event_sleep = B_TRUE;
2973 }
2974 poll_period = BSC_EVENT_POLL_NORMAL;
2975
2976 if (async_reg) {
2977 ssp->status_change = B_TRUE;
2978 ssp->event_waiting = B_TRUE;
2979 }
2980 } else if (ssp->cssp_prog) {
2981 /*
2982 * Expect radio silence or error values
2983 * when the CSSP is upgrading the BSC firmware
2984 * so throw away any fault indication.
2985 */
2986 fault = B_FALSE;
2987 } else if (fault_cnt == BSC_PROBE_FAULT_LIMIT) {
2988 /* Count previous faults and maybe fail */
2989 /* Declare the lom broken */
2990 bscv_set_fault(ssp);
2991 poll_period = BSC_EVENT_POLL_FAULTY;
2992 cmn_err(CE_WARN,
2993 "!bscv_event_daemon had faults probing "
2994 "lom - marking it as faulty.");
2995 /*
2996 * Increment fault_cnt to ensure that
2997 * next time we do not report a message
2998 * i.e. we drop out of the bottom
2999 */
3000 fault_cnt = BSC_PROBE_FAULT_LIMIT + 1;
3001 ssp->event_sleep = B_TRUE;
3002 } else if (fault_cnt < BSC_PROBE_FAULT_LIMIT) {
3003 if (bscv_faulty(ssp)) {
3004 poll_period = BSC_EVENT_POLL_FAULTY;
3005 /*
3006 * No recovery messages in this case
3007 * because there was never a fault
3008 * message here.
3009 */
3010 fault_cnt = 0;
3011 } else {
3012 /* Getting ready to explode */
3013 fault_cnt++;
3014 cmn_err(CE_WARN,
3015 "!bscv_event_daemon had fault 0x%x",
3016 fault);
3017 }
3018 ssp->event_sleep = B_TRUE;
3019 }
3020 bscv_exit(ssp);
3021 mutex_enter(&ssp->task_mu);
3022 }
3023
3024 #if defined(__i386) || defined(__amd64)
3025 /*
3026 * we have no platmod hook on Solaris x86 to report
3027 * a change to the nodename so we keep a copy so
3028 * we can detect a change and request that the bsc
3029 * be updated when appropriate.
3030 */
3031 if (strcmp(ssp->last_nodename, utsname.nodename) != 0) {
3032
3033 BSCV_TRACE(ssp, 'X', "bscv_event_daemon",
3034 "utsname.nodename='%s' possible change detected",
3035 utsname.nodename);
3036 ssp->nodename_change = B_TRUE;
3037 (void) strncpy(ssp->last_nodename, utsname.nodename,
3038 sizeof (ssp->last_nodename));
3039 /* enforce null termination */
3040 ssp->last_nodename[sizeof (ssp->last_nodename) - 1] =
3041 '\0';
3042 }
3043 #endif /* __i386 || __amd64 */
3044
3045 if (((ssp->task_flags & TASK_PAUSE_FLG) == 0) &&
3046 fault_cnt == 0 && ssp->cssp_prog == B_FALSE &&
3047 (ssp->event_waiting || ssp->status_change ||
3048 ssp->nodename_change || ssp->watchdog_change)) {
3049
3050 do_events = ssp->event_waiting;
3051 ssp->event_waiting = B_FALSE;
3052 ssp->task_flags |= do_events ?
3053 TASK_EVENT_PENDING_FLG : 0;
3054 do_status = ssp->status_change;
3055 ssp->status_change = B_FALSE;
3056 do_nodename = ssp->nodename_change;
3057 ssp->nodename_change = B_FALSE;
3058 do_watchdog = ssp->watchdog_change;
3059 if (ssp->watchdog_change) {
3060 ssp->watchdog_change = B_FALSE;
3061 }
3062
3063 mutex_exit(&ssp->task_mu);
3064 /*
3065 * We must not hold task_mu whilst processing
3066 * events because this can lead to priority
3067 * inversion and hence our interrupts getting
3068 * locked out.
3069 */
3070 bscv_enter(ssp);
3071 if (do_events) {
3072 bscv_event_process(ssp, do_events);
3073 }
3074 if (do_nodename) {
3075 BSCV_TRACE(ssp, 'D', "bscv_event_daemon",
3076 "do_nodename task");
3077 bscv_setup_hostname(ssp);
3078 }
3079 if (do_watchdog) {
3080 BSCV_TRACE(ssp, 'D', "bscv_event_daemon",
3081 "do_watchdog task");
3082 bscv_setup_watchdog(ssp);
3083 }
3084 /*
3085 * Pending status changes are dealt with last because
3086 * if we see that the BSC is about to be programmed,
3087 * then it will expect us to to quiescent in the
3088 * first second so it can cleanly tear down its comms
3089 * protocols; this takes ~100 ms.
3090 */
3091 if (do_status) {
3092 bscv_get_state_changes(ssp);
3093 }
3094 if (bscv_session_error(ssp)) {
3095 /*
3096 * Had fault during event session. We always
3097 * sleep after one of these because there
3098 * may be a problem with the lom which stops
3099 * us doing useful work in the event daemon.
3100 * If we don't sleep then we may livelock.
3101 */
3102 BSCV_TRACE(ssp, 'D', "bscv_event_daemon",
3103 "had session error - sleeping");
3104 ssp->event_sleep = B_TRUE;
3105 }
3106 bscv_exit(ssp);
3107
3108 mutex_enter(&ssp->task_mu);
3109
3110 if (ssp->task_flags & TASK_EVENT_PENDING_FLG) {
3111 /*
3112 * We have read any events which were
3113 * pending. Let the consumer continue.
3114 * Ignore the race condition with new events
3115 * arriving - just let the consumer have
3116 * whatever was pending when they asked.
3117 */
3118 ssp->event_active_count++;
3119 ssp->task_flags &= ~(TASK_EVENT_PENDING_FLG |
3120 TASK_EVENT_CONSUMER_FLG);
3121 cv_broadcast(&ssp->task_evnt_cv);
3122 }
3123 } else {
3124 /* There was nothing to do - sleep */
3125 ssp->event_sleep = B_TRUE;
3126 }
3127
3128 if (ssp->event_sleep) {
3129 ssp->task_flags |= TASK_SLEEPING_FLG;
3130 /* Sleep until there is something to do */
3131 (void) cv_reltimedwait(&ssp->task_cv,
3132 &ssp->task_mu, poll_period, TR_CLOCK_TICK);
3133 ssp->task_flags &= ~TASK_SLEEPING_FLG;
3134 ssp->event_sleep = B_FALSE;
3135 }
3136 }
3137
3138 if (ssp->task_flags & TASK_EVENT_CONSUMER_FLG) {
3139 /*
3140 * We are going away so wake up any event consumer.
3141 * Pretend that any pending events have been processed.
3142 */
3143 ssp->event_active_count += 2;
3144 cv_broadcast(&ssp->task_evnt_cv);
3145 }
3146
3147 ASSERT(!(ssp->task_flags & TASK_EVENT_PENDING_FLG));
3148 ssp->task_flags &=
3149 ~(TASK_STOP_FLG | TASK_ALIVE_FLG | TASK_EVENT_CONSUMER_FLG);
3150 mutex_exit(&ssp->task_mu);
3151
3152 BSCV_TRACE(ssp, 'D', "bscv_event_daemon",
3153 "exiting.");
3154 }
3155
3156 /*
3157 * function - bscv_start_event_daemon
3158 * description - Create the event daemon thread.
3159 * inputs - LOM soft state structure pointer
3160 * outputs - none
3161 */
3162 static void
3163 bscv_start_event_daemon(bscv_soft_state_t *ssp)
3164 {
3165 if (ssp->progress & BSCV_THREAD)
3166 return;
3167
3168 /* Start the event thread after the queue has started */
3169 (void) thread_create(NULL, 0, (void (*)())bscv_event_daemon, ssp,
3170 0, &p0, TS_RUN, minclsyspri);
3171
3172 ssp->progress |= BSCV_THREAD;
3173 }
3174
3175 /*
3176 * function - bscv_stop_event_daemon
3177 * description - Attempt to stop the event daemon thread.
3178 * inputs - LOM soft state structure pointer
3179 * outputs - DDI_SUCCESS OR DDI_FAILURE
3180 */
3181 static int
3182 bscv_stop_event_daemon(bscv_soft_state_t *ssp)
3183 {
3184 int try;
3185 int res = DDI_SUCCESS;
3186
3187 mutex_enter(&ssp->task_mu);
3188
3189 /* Wait for task daemon to stop running. */
3190 for (try = 0;
3191 ((ssp->task_flags & TASK_ALIVE_FLG) && try < 10);
3192 try++) {
3193 /* Signal that the task daemon should stop */
3194 ssp->task_flags |= TASK_STOP_FLG;
3195 cv_signal(&ssp->task_cv);
3196 /* Release task daemon lock. */
3197 mutex_exit(&ssp->task_mu);
3198 /*
3199 * TODO - when the driver is modified to support
3200 * system suspend or if this routine gets called
3201 * during panic we should use drv_usecwait() rather
3202 * than delay in those circumstances.
3203 */
3204 delay(drv_usectohz(1000000));
3205 mutex_enter(&ssp->task_mu);
3206 }
3207
3208 if (ssp->task_flags & TASK_ALIVE_FLG) {
3209 res = DDI_FAILURE;
3210 }
3211 mutex_exit(&ssp->task_mu);
3212
3213 return (res);
3214 }
3215
3216 /*
3217 * function - bscv_pause_event_daemon
3218 * description - Attempt to pause the event daemon thread.
3219 * inputs - LOM soft state structure pointer
3220 * outputs - DDI_SUCCESS OR DDI_FAILURE
3221 */
3222 static int
3223 bscv_pause_event_daemon(bscv_soft_state_t *ssp)
3224 {
3225 int try;
3226
3227 if (!(ssp->progress & BSCV_THREAD)) {
3228 /* Nothing to do */
3229 return (BSCV_SUCCESS);
3230 }
3231
3232 BSCV_TRACE(ssp, 'D', "bscv_pause_event_daemon",
3233 "Attempting to pause event daemon");
3234
3235 mutex_enter(&ssp->task_mu);
3236 /* Signal that the task daemon should pause */
3237 ssp->task_flags |= TASK_PAUSE_FLG;
3238
3239 /* Wait for task daemon to pause. */
3240 for (try = 0;
3241 (!(ssp->task_flags & TASK_SLEEPING_FLG) &&
3242 (ssp->task_flags & TASK_ALIVE_FLG) &&
3243 try < 10);
3244 try++) {
3245 /* Paranoia */
3246 ssp->task_flags |= TASK_PAUSE_FLG;
3247 cv_signal(&ssp->task_cv);
3248 /* Release task daemon lock. */
3249 mutex_exit(&ssp->task_mu);
3250 delay(drv_usectohz(1000000));
3251 mutex_enter(&ssp->task_mu);
3252 }
3253 if ((ssp->task_flags & TASK_SLEEPING_FLG) ||
3254 !(ssp->task_flags & TASK_ALIVE_FLG)) {
3255 mutex_exit(&ssp->task_mu);
3256 BSCV_TRACE(ssp, 'D', "bscv_pause_event_daemon",
3257 "Pause event daemon - success");
3258 return (BSCV_SUCCESS);
3259 }
3260 mutex_exit(&ssp->task_mu);
3261 BSCV_TRACE(ssp, 'D', "bscv_pause_event_daemon",
3262 "Pause event daemon - failed");
3263 return (BSCV_FAILURE);
3264 }
3265
3266 /*
3267 * function - bscv_resume_event_daemon
3268 * description - Resumethe event daemon thread.
3269 * inputs - LOM soft state structure pointer
3270 * outputs - None.
3271 */
3272 static void
3273 bscv_resume_event_daemon(bscv_soft_state_t *ssp)
3274 {
3275 if (!(ssp->progress & BSCV_THREAD)) {
3276 /* Nothing to do */
3277 return;
3278 }
3279
3280 mutex_enter(&ssp->task_mu);
3281 /* Allow the task daemon to resume event processing */
3282 ssp->task_flags &= ~TASK_PAUSE_FLG;
3283 cv_signal(&ssp->task_cv);
3284 mutex_exit(&ssp->task_mu);
3285
3286 BSCV_TRACE(ssp, 'D', "bscv_pause_event_daemon",
3287 "Event daemon resumed");
3288 }
3289
3290 /*
3291 * function - bscv_event_process
3292 * description - process (report) events
3293 * inputs - Soft state ptr, process event request
3294 * outputs - none
3295 */
3296 static void
3297 bscv_event_process(bscv_soft_state_t *ssp, boolean_t do_events)
3298 {
3299 uint32_t currptr;
3300 unsigned int count;
3301
3302 /* Raw values read from the lom */
3303 uint8_t evcount;
3304 uint16_t logptr;
3305
3306 lom_event_t event;
3307
3308 if (do_events) {
3309 /*
3310 * Read count, next event ptr MSB,LSB. Note a read of count
3311 * latches values for the next event ptr
3312 */
3313 evcount = bscv_get8(ssp, chan_general, EBUS_IDX_UNREAD_EVENTS);
3314 logptr = bscv_get16(ssp, chan_general, EBUS_IDX_LOG_PTR_HI);
3315
3316 /* Sanity check the values from the lom */
3317 count = bscv_event_validate(ssp, logptr, evcount);
3318
3319 if (count == -1) {
3320 /*
3321 * Nothing to do - or badly configured event log.
3322 * We really do not want to touch the lom in this
3323 * case because any data that we access may be bad!
3324 * This differs from zero because if we have zero
3325 * to read the lom probably things that unread is
3326 * non-zero and we want that to be set to zero!
3327 * Signal event fault to make the thread wait
3328 * before attempting to re-read the log.
3329 */
3330 ssp->event_sleep = B_TRUE;
3331
3332 goto logdone;
3333 }
3334 if (ssp->event_fault_reported) {
3335 /* Clear down any old status - things are fixed */
3336 cmn_err(CE_NOTE, "Event pointer fault recovered.");
3337 ssp->event_fault_reported = B_FALSE;
3338 }
3339
3340 /* Compute the first entry that we need to read. */
3341 currptr = logptr - ssp->eventlog_start;
3342 currptr += ssp->eventlog_size;
3343 currptr -= (count * sizeof (event));
3344 currptr %= ssp->eventlog_size;
3345 currptr += ssp->eventlog_start;
3346
3347 BSCV_TRACE(ssp, 'E', "bscv_event_process",
3348 "processing %d events from 0x%x in 0x%x:0x%x",
3349 count, currptr,
3350 ssp->eventlog_start,
3351 ssp->eventlog_start + ssp->eventlog_size);
3352
3353 for (; count > 0; count--) {
3354 /* Ensure window is positioned correctly */
3355 if (bscv_eerw(ssp, currptr, (uint8_t *)&event,
3356 sizeof (event), B_FALSE /* read */) != 0) {
3357 /* Fault reading data - stop */
3358 break;
3359 }
3360
3361 bscv_event_process_one(ssp, &event);
3362 bscv_sysevent(ssp, &event);
3363
3364 currptr += sizeof (event);
3365 if (currptr >= ssp->eventlog_start +
3366 ssp->eventlog_size) {
3367 currptr = ssp->eventlog_start;
3368 }
3369 }
3370 /*
3371 * Clear event count - write the evcount value to remove that
3372 * many from the unread total.
3373 * Adjust the value to reflect how many we have left to
3374 * read just in case we had a failure reading events.
3375 */
3376 if (count == 0) {
3377 /*EMPTY*/
3378 ASSERT(logptr == currptr);
3379 } else if (count > evcount) {
3380 evcount = 0;
3381 } else {
3382 evcount -= count;
3383 }
3384 bscv_put8(ssp, chan_general, EBUS_IDX_UNREAD_EVENTS, evcount);
3385 /* Remember where we were for next time */
3386 ssp->oldeeptr = currptr;
3387 ssp->oldeeptr_valid = B_TRUE;
3388 logdone:
3389 ;
3390 }
3391 }
3392
3393 /*
3394 * function - bscv_event_validate
3395 * description - validate the event data supplied by the lom and determine
3396 * how many (if any) events to read.
3397 * This function performs complex checks to ensure that
3398 * events are not lost due to lom resets or host resets.
3399 * A combination of lom reset and host reset (i.e. power fail)
3400 * may cause some events to not be reported.
3401 * inputs - Soft state ptr, next event pointer, number of unread events.
3402 * outputs - the number of events to read. -1 on error.
3403 * zero is a valid value because it forces the loms unread
3404 * count to be cleared.
3405 */
3406 static int
3407 bscv_event_validate(bscv_soft_state_t *ssp, uint32_t newptr, uint8_t unread)
3408 {
3409 uint32_t oldptr;
3410 unsigned int count;
3411
3412 if (!bscv_window_setup(ssp)) {
3413 /* Problem with lom eeprom setup we cannot do anything */
3414 return (-1);
3415 }
3416
3417 /* Sanity check the event pointers */
3418 if ((newptr < ssp->eventlog_start) ||
3419 (newptr >= (ssp->eventlog_start + ssp->eventlog_size))) {
3420 if (!ssp->event_fault_reported) {
3421 cmn_err(CE_WARN, "Event pointer out of range. "
3422 "Cannot read events.");
3423 ssp->event_fault_reported = B_TRUE;
3424 }
3425 return (-1);
3426 }
3427 oldptr = ssp->oldeeptr;
3428 /* Now sanity check log pointer against count */
3429 if (newptr < oldptr) {
3430 /*
3431 * Must have wrapped add eventlog_size to get the
3432 * correct relative values - this makes the checks
3433 * below work!
3434 */
3435 newptr += ssp->eventlog_size;
3436 }
3437 if (!ssp->oldeeptr_valid) {
3438 /* We have just started up - we have to trust lom */
3439 count = unread;
3440 } else if ((unread == 0) && (newptr == oldptr)) {
3441 /* Nothing to do - we were just polling */
3442 return (-1);
3443 } else if (oldptr + (unread * sizeof (lom_event_t)) == newptr) {
3444 /* Ok - got as many events as we expected */
3445 count = unread;
3446 } else if (oldptr + (unread * sizeof (lom_event_t)) > newptr) {
3447 /*
3448 * Errrm more messages than there should have been.
3449 * Possible causes:
3450 * 1. the event log has filled - we have been
3451 * away for a long time
3452 * 2. software bug in lom or driver.
3453 * 3. something that I haven't thought of!
3454 * Always warn about this we should really never
3455 * see it!
3456 */
3457 count = (newptr - oldptr) / sizeof (lom_event_t);
3458 BSCV_TRACE(ssp, 'E', "bscv_event_process",
3459 "bscv_event_process: lom reported "
3460 "more events (%d) than expected (%d).",
3461 unread, count);
3462 cmn_err(CE_CONT, "only processing %d events", count);
3463 } else {
3464 /* Less messages - perhaps the lom has been reset */
3465 count = (newptr - oldptr) / sizeof (lom_event_t);
3466 BSCV_TRACE(ssp, 'E', "bscv_event_process",
3467 "lom reported less events (%d) than expected (%d)"
3468 " - the lom may have been reset",
3469 unread, count);
3470 }
3471 /* Whatever happens only read a maximum of 255 entries */
3472 if ((count >= 0xff)) {
3473 cmn_err(CE_WARN,
3474 "bscv_event_process: too many events (%d) to "
3475 "process - some may have been lost", count);
3476 count = 0xff;
3477 }
3478 return (count);
3479 }
3480
3481 /*
3482 * function - bscv_event_process_one
3483 * description - reports on state changes to the host.
3484 *
3485 * inputs - LOM soft state structure pointer.
3486 *
3487 * outputs - none.
3488 */
3489
3490 static void
3491 bscv_event_process_one(bscv_soft_state_t *ssp, lom_event_t *event)
3492 {
3493 int level;
3494 char eventstr[100];
3495 int msg_type = 0;
3496
3497 if (bscv_is_null_event(ssp, event)) {
3498 /* Cleared entry - do not report it */
3499 return;
3500 }
3501
3502 level = bscv_level_of_event(event);
3503
3504 switch (level) {
3505 default:
3506 msg_type = CE_NOTE;
3507 break;
3508
3509 case EVENT_LEVEL_FATAL:
3510 case EVENT_LEVEL_FAULT:
3511 msg_type = CE_WARN;
3512 break;
3513 }
3514
3515 bscv_build_eventstring(ssp, event, eventstr, eventstr +
3516 sizeof (eventstr));
3517
3518 if (level <= ssp->reporting_level) {
3519 /*
3520 * The message is important enough to be shown on the console
3521 * as well as the log.
3522 */
3523 cmn_err(msg_type, "%s", eventstr);
3524 } else {
3525 /*
3526 * The message goes only to the log.
3527 */
3528 cmn_err(msg_type, "!%s", eventstr);
3529 }
3530 }
3531
3532 /*
3533 * time formats
3534 *
3535 * The BSC represents times as seconds since epoch 1970. Currently it gives
3536 * us 32 bits, unsigned. In the future this might change to a 64-bit count,
3537 * to allow a greater range.
3538 *
3539 * Timestamp values below BSC_TIME_SANITY do not represent an absolute time,
3540 * but instead represent an offset from the last reset. This must be
3541 * borne in mind by output routines.
3542 */
3543
3544 typedef uint32_t bsctime_t;
3545
3546 #define BSC_TIME_SANITY 1000000000
3547
3548 /*
3549 * render a formatted time for display
3550 */
3551
3552 static size_t
3553 bscv_event_snprintgmttime(char *buf, size_t bufsz, todinfo_t t)
3554 {
3555 int year;
3556
3557 /* tod_year is base 1900 so this code needs to adjust */
3558 year = 1900 + t.tod_year;
3559
3560 return (snprintf(buf, bufsz, "%04d-%02d-%02d %02d:%02d:%02dZ",
3561 year, t.tod_month, t.tod_day, t.tod_hour,
3562 t.tod_min, t.tod_sec));
3563 }
3564
3565 /*
3566 * function - bscv_build_eventstring
3567 * description - reports on state changes to the host.
3568 *
3569 * inputs - LOM soft state structure pointer.
3570 *
3571 * outputs - none.
3572 */
3573
3574 static void
3575 bscv_build_eventstring(bscv_soft_state_t *ssp, lom_event_t *event,
3576 char *buf, char *bufend)
3577 {
3578 uint8_t subsystem;
3579 uint8_t eventtype;
3580 bsctime_t bsctm;
3581
3582 BSCV_TRACE(ssp, 'S', "bscv_build_eventstring", "event %2x%2x%2x%2x",
3583 event->ev_subsys, event->ev_event,
3584 event->ev_resource, event->ev_detail);
3585 BSCV_TRACE(ssp, 'S', "bscv_build_eventstring", "time %2x%2x%2x%2x",
3586 event->ev_data[0], event->ev_data[1],
3587 event->ev_data[2], event->ev_data[3]);
3588
3589 /*
3590 * We accept bad subsystems and event type codes here.
3591 * The code decodes as much as possible and then produces
3592 * suitable output.
3593 */
3594 subsystem = EVENT_DECODE_SUBSYS(event->ev_subsys);
3595 eventtype = event->ev_event;
3596
3597 /* time */
3598 bsctm = (((uint32_t)event->ev_data[0]) << 24) |
3599 (((uint32_t)event->ev_data[1]) << 16) |
3600 (((uint32_t)event->ev_data[2]) << 8) |
3601 ((uint32_t)event->ev_data[3]);
3602 if (bsctm < BSC_TIME_SANITY) {
3603 /* offset */
3604 buf += snprintf(buf, bufend-buf, "+P%dd%02dh%02dm%02ds",
3605 (int)(bsctm/86400), (int)(bsctm/3600%24),
3606 (int)(bsctm/60%60), (int)(bsctm%60));
3607 } else {
3608 /* absolute time */
3609 mutex_enter(&tod_lock);
3610 buf += bscv_event_snprintgmttime(buf, bufend-buf,
3611 utc_to_tod(bsctm));
3612 mutex_exit(&tod_lock);
3613 }
3614 buf += snprintf(buf, bufend-buf, " ");
3615
3616 /* subsysp */
3617 if (subsystem <
3618 (sizeof (eventSubsysStrings)/sizeof (*eventSubsysStrings))) {
3619 buf += snprintf(buf, bufend - buf, "%s",
3620 eventSubsysStrings[subsystem]);
3621 } else {
3622 buf += snprintf(buf, bufend - buf,
3623 "unknown subsystem %d ", subsystem);
3624 }
3625
3626 /* resource */
3627 switch (subsystem) {
3628 case EVENT_SUBSYS_ALARM:
3629 case EVENT_SUBSYS_TEMP:
3630 case EVENT_SUBSYS_OVERTEMP:
3631 case EVENT_SUBSYS_FAN:
3632 case EVENT_SUBSYS_SUPPLY:
3633 case EVENT_SUBSYS_BREAKER:
3634 case EVENT_SUBSYS_PSU:
3635 buf += snprintf(buf, bufend - buf, "%d ", event->ev_resource);
3636 break;
3637 case EVENT_SUBSYS_LED:
3638 buf += snprintf(buf, bufend - buf, "%s ", bscv_get_label(
3639 ssp->led_names, MAX_LED_ID, event->ev_resource - 1));
3640 break;
3641 default:
3642 break;
3643 }
3644
3645 /* fatal */
3646 if (event->ev_subsys & EVENT_MASK_FAULT) {
3647 if (event->ev_subsys & EVENT_MASK_FATAL) {
3648 buf += snprintf(buf, bufend - buf, "FATAL FAULT: ");
3649 } else {
3650 buf += snprintf(buf, bufend - buf, "FAULT: ");
3651 }
3652 }
3653
3654 /* eventp */
3655 if (eventtype <
3656 (sizeof (eventTypeStrings)/sizeof (*eventTypeStrings))) {
3657 buf += snprintf(buf, bufend - buf, "%s",
3658 eventTypeStrings[eventtype]);
3659 } else {
3660 buf += snprintf(buf, bufend - buf,
3661 "unknown event 0x%02x%02x%02x%02x",
3662 event->ev_subsys, event->ev_event,
3663 event->ev_resource, event->ev_detail);
3664 }
3665
3666 /* detail */
3667 switch (subsystem) {
3668 case EVENT_SUBSYS_TEMP:
3669 if ((eventtype != EVENT_RECOVERED) &&
3670 eventtype != EVENT_DEVICE_INACCESSIBLE) {
3671 buf += snprintf(buf, bufend - buf, " - %d degC",
3672 (int8_t)event->ev_detail);
3673 }
3674 break;
3675 case EVENT_SUBSYS_FAN:
3676 if (eventtype == EVENT_FAILED) {
3677 buf += snprintf(buf, bufend - buf,
3678 " %d%%", event->ev_detail);
3679 }
3680 break;
3681 case EVENT_SUBSYS_LOM:
3682 switch (eventtype) {
3683 case EVENT_FLASH_DOWNLOAD:
3684 buf += snprintf(buf, bufend - buf,
3685 ": v%d.%d to v%d.%d",
3686 (event->ev_resource >> 4),
3687 (event->ev_resource & 0x0f),
3688 (event->ev_detail >> 4),
3689 (event->ev_detail & 0x0f));
3690 break;
3691 case EVENT_WATCHDOG_TRIGGER:
3692 buf += snprintf(buf, bufend - buf,
3693 event->ev_detail ? "- soft" : " - hard");
3694 break;
3695 case EVENT_UNEXPECTED_RESET:
3696 if (event->ev_detail &
3697 LOM_UNEXPECTEDRESET_MASK_BADTRAP) {
3698 buf += snprintf(buf, bufend - buf,
3699 " - unclaimed exception 0x%x",
3700 event->ev_detail &
3701 ~LOM_UNEXPECTEDRESET_MASK_BADTRAP);
3702 }
3703 break;
3704 case EVENT_RESET:
3705 switch (event->ev_detail) {
3706 case LOM_RESET_DETAIL_BYUSER:
3707 buf += snprintf(buf, bufend - buf, " by user");
3708 break;
3709 case LOM_RESET_DETAIL_REPROGRAMMING:
3710 buf += snprintf(buf, bufend - buf,
3711 " after flash download");
3712 break;
3713 default:
3714 buf += snprintf(buf, bufend - buf,
3715 " - unknown reason");
3716 break;
3717 }
3718 break;
3719 default:
3720 break;
3721 }
3722 break;
3723 case EVENT_SUBSYS_LED:
3724 switch (event->ev_detail) {
3725 case LOM_LED_STATE_OFF:
3726 buf += snprintf(buf, bufend - buf, ": OFF");
3727 break;
3728 case LOM_LED_STATE_ON_STEADY:
3729 buf += snprintf(buf, bufend - buf, ": ON");
3730 break;
3731 case LOM_LED_STATE_ON_FLASHING:
3732 case LOM_LED_STATE_ON_SLOWFLASH:
3733 buf += snprintf(buf, bufend - buf, ": BLINKING");
3734 break;
3735 case LOM_LED_STATE_INACCESSIBLE:
3736 buf += snprintf(buf, bufend - buf, ": inaccessible");
3737 break;
3738 case LOM_LED_STATE_STANDBY:
3739 buf += snprintf(buf, bufend - buf, ": standby");
3740 break;
3741 case LOM_LED_STATE_NOT_PRESENT:
3742 buf += snprintf(buf, bufend - buf, ": not present");
3743 break;
3744 default:
3745 buf += snprintf(buf, bufend - buf, ": 0x%x",
3746 event->ev_resource);
3747 break;
3748 }
3749 break;
3750 case EVENT_SUBSYS_USER:
3751 switch (eventtype) {
3752 case EVENT_USER_ADDED:
3753 case EVENT_USER_REMOVED:
3754 case EVENT_USER_PERMSCHANGED:
3755 case EVENT_USER_LOGIN:
3756 case EVENT_USER_PASSWORD_CHANGE:
3757 case EVENT_USER_LOGINFAIL:
3758 case EVENT_USER_LOGOUT:
3759 buf += snprintf(buf, bufend - buf, " %d",
3760 event->ev_resource);
3761 default:
3762 break;
3763 }
3764 break;
3765 case EVENT_SUBSYS_PSU:
3766 if (event->ev_detail & LOM_PSU_NOACCESS) {
3767 buf += snprintf(buf, bufend - buf, " - inaccessible");
3768 } else if ((event->ev_detail & LOM_PSU_STATUS_MASK)
3769 == LOM_PSU_STATUS_MASK) {
3770 buf += snprintf(buf, bufend - buf, " - OK");
3771 } else {
3772 buf += snprintf(buf, bufend - buf, " -");
3773 /*
3774 * If both inputs are seen to have failed then simply
3775 * indicate that the PSU input has failed
3776 */
3777 if (!(event->ev_detail &
3778 (LOM_PSU_INPUT_A_OK | LOM_PSU_INPUT_B_OK))) {
3779 buf += snprintf(buf, bufend - buf, " Input");
3780 } else {
3781 /* At least one input is ok */
3782 if (!(event->ev_detail & LOM_PSU_INPUT_A_OK)) {
3783 buf += snprintf(buf, bufend - buf,
3784 " InA");
3785 }
3786 if (!(event->ev_detail & LOM_PSU_INPUT_B_OK)) {
3787 buf += snprintf(buf, bufend - buf,
3788 " InB");
3789 }
3790 /*
3791 * Only flag an output error if an input is
3792 * still present
3793 */
3794 if (!(event->ev_detail & LOM_PSU_OUTPUT_OK)) {
3795 buf += snprintf(buf, bufend - buf,
3796 " Output");
3797 }
3798 }
3799 buf += snprintf(buf, bufend - buf, " failed");
3800 }
3801 break;
3802 case EVENT_SUBSYS_NONE:
3803 if (eventtype == EVENT_FAULT_LED) {
3804 switch (event->ev_detail) {
3805 case 0:
3806 buf += snprintf(buf, bufend - buf, " - ON");
3807 break;
3808 case 255:
3809 buf += snprintf(buf, bufend - buf, " - OFF");
3810 break;
3811 default:
3812 buf += snprintf(buf, bufend - buf,
3813 " - %dHz", event->ev_detail);
3814 break;
3815 }
3816 }
3817 break;
3818 case EVENT_SUBSYS_HOST:
3819 if (eventtype == EVENT_BOOTMODE_CHANGE) {
3820 switch (event->ev_detail &
3821 ~EBUS_BOOTMODE_FORCE_CONSOLE) {
3822 case EBUS_BOOTMODE_FORCE_NOBOOT:
3823 buf += snprintf(buf, bufend - buf,
3824 " - no boot");
3825 break;
3826 case EBUS_BOOTMODE_RESET_DEFAULT:
3827 buf += snprintf(buf, bufend - buf,
3828 " - reset defaults");
3829 break;
3830 case EBUS_BOOTMODE_FULLDIAG:
3831 buf += snprintf(buf, bufend - buf,
3832 " - full diag");
3833 break;
3834 case EBUS_BOOTMODE_SKIPDIAG:
3835 buf += snprintf(buf, bufend - buf,
3836 " - skip diag");
3837 break;
3838 default:
3839 break;
3840 }
3841 }
3842 if (eventtype == EVENT_SCC_STATUS) {
3843 switch (event->ev_detail) {
3844 case 0:
3845 buf += snprintf(buf, bufend - buf,
3846 " - inserted");
3847 break;
3848 case 1:
3849 buf += snprintf(buf, bufend - buf,
3850 " - removed");
3851 break;
3852 default:
3853 break;
3854 }
3855 }
3856 break;
3857
3858 default:
3859 break;
3860 }
3861
3862 /* shutd */
3863 if (event->ev_subsys & EVENT_MASK_SHUTDOWN_REQD) {
3864 buf += snprintf(buf, bufend - buf, " - shutdown req'd");
3865 }
3866
3867 buf += snprintf(buf, bufend - buf, "\n");
3868
3869 if (buf >= bufend) {
3870 /* Ensure newline at end of string */
3871 bufend[-2] = '\n';
3872 bufend[-1] = '\0';
3873 #ifdef DEBUG
3874 cmn_err(CE_WARN, "!bscv_build_eventstring: buffer too small!");
3875 #endif /* DEBUG */
3876 }
3877 }
3878
3879 /*
3880 * function - bscv_level_of_event
3881 * description - This routine determines which level an event should be
3882 * reported at.
3883 * inputs - lom event structure pointer
3884 * outputs - event level.
3885 */
3886 static int
3887 bscv_level_of_event(lom_event_t *event)
3888 {
3889 int level;
3890 /*
3891 * This is the same criteria that the firmware uses except we
3892 * log the fault led on as being EVENT_LEVEL_FAULT
3893 */
3894 if (EVENT_DECODE_SUBSYS(event->ev_subsys) == EVENT_SUBSYS_USER) {
3895 level = EVENT_LEVEL_USER;
3896 } else if ((EVENT_DECODE_SUBSYS(event->ev_subsys) ==
3897 EVENT_SUBSYS_ALARM) && (event->ev_event == EVENT_STATE_ON)) {
3898 level = EVENT_LEVEL_FAULT;
3899 } else if ((EVENT_DECODE_SUBSYS(event->ev_subsys) ==
3900 EVENT_SUBSYS_NONE) &&
3901 (event->ev_event == EVENT_FAULT_LED) &&
3902 (event->ev_detail != 0xff)) {
3903 level = EVENT_LEVEL_FAULT;
3904 } else if ((EVENT_DECODE_SUBSYS(event->ev_subsys) ==
3905 EVENT_SUBSYS_LOM) && event->ev_event == EVENT_TIME_REFERENCE) {
3906 level = EVENT_LEVEL_NOTICE;
3907 } else if (event->ev_event == EVENT_RECOVERED) {
3908 /*
3909 * All recovery messages need to be reported to the console
3910 * because during boot, the faults which occurred whilst
3911 * Solaris was not running are relayed to the console. There
3912 * is a case whereby a fatal fault (eg. over temp) could
3913 * have occurred and then recovered. The recovery condition
3914 * needs to be reported so the user doesn't think that the
3915 * failure (over temp) is still present.
3916 */
3917 level = EVENT_LEVEL_FAULT;
3918 } else if (EVENT_DECODE_FAULT(event->ev_subsys) == 0) {
3919 /* None of FAULT, FATAL or SHUTDOWN REQD are set */
3920 level = EVENT_LEVEL_NOTICE;
3921 } else if (EVENT_DECODE_FAULT(event->ev_subsys) == EVENT_MASK_FAULT) {
3922 /* Only FAULT set i.e not FATAL or SHUTDOWN REQD */
3923 level = EVENT_LEVEL_FAULT;
3924 } else {
3925 level = EVENT_LEVEL_FATAL;
3926 }
3927
3928 return (level);
3929 }
3930
3931 /*
3932 * function - bscv_status
3933 * description - This routine is called when any change in the LOMlite2 status
3934 * is indicated by the status registers.
3935 *
3936 * inputs - LOM soft state structure pointer
3937 *
3938 * outputs - none.
3939 */
3940 static void
3941 bscv_status(bscv_soft_state_t *ssp, uint8_t state_chng, uint8_t dev_no)
3942 {
3943 int8_t temp;
3944 uint8_t fanspeed;
3945
3946 ASSERT(bscv_held(ssp));
3947
3948 BSCV_TRACE(ssp, 'D', "bscv_status", "state_chng 0x%x dev_no 0x%x",
3949 state_chng, dev_no);
3950
3951 /*
3952 * The device that has changed is given by the state change
3953 * register and the event detail register so react
3954 * accordingly.
3955 */
3956
3957 if (state_chng == EBUS_STATE_NOTIFY) {
3958 /*
3959 * The BSC is indicating a self state change
3960 */
3961 if (dev_no == EBUS_DETAIL_FLASH) {
3962 ssp->cssp_prog = B_TRUE;
3963 BSCV_TRACE(ssp, 'D', "bscv_status",
3964 "ssp->cssp_prog changed to 0x%x",
3965 ssp->cssp_prog);
3966 /*
3967 * It takes the BSC at least 100 ms to
3968 * clear down the comms protocol.
3969 * We back-off from talking to the
3970 * BSC during this period.
3971 */
3972 delay(BSC_EVENT_POLL_NORMAL);
3973 BSCV_TRACE(ssp, 'D', "bscv_status",
3974 "completed delay");
3975 } else if (dev_no == EBUS_DETAIL_RESET) {
3976 /*
3977 * The bsc has reset
3978 */
3979 BSCV_TRACE(ssp, 'D', "bscv_status",
3980 "BSC reset occured, re-synching");
3981 (void) bscv_attach_common(ssp);
3982 BSCV_TRACE(ssp, 'D', "bscv_status",
3983 "completed attach_common");
3984 }
3985
3986 }
3987
3988 if ((state_chng & EBUS_STATE_FAN) && ((dev_no - 1) < MAX_FANS)) {
3989 fanspeed = bscv_get8(ssp, chan_general,
3990 EBUS_IDX_FAN1_SPEED + dev_no - 1);
3991 /*
3992 * Only remember fanspeeds which are real values or
3993 * NOT PRESENT values.
3994 */
3995 if ((fanspeed <= LOM_FAN_MAX_SPEED) ||
3996 (fanspeed == LOM_FAN_NOT_PRESENT)) {
3997 ssp->fanspeed[dev_no - 1] = fanspeed;
3998 }
3999 }
4000
4001 if ((state_chng & EBUS_STATE_PSU) && ((dev_no - 1) < MAX_PSUS)) {
4002 (void) bscv_get8(ssp, chan_general,
4003 EBUS_IDX_PSU1_STAT + dev_no - 1);
4004 }
4005
4006 if (state_chng & EBUS_STATE_GP) {
4007 (void) bscv_get8(ssp, chan_general, EBUS_IDX_GPIP);
4008 }
4009
4010 if (state_chng & EBUS_STATE_CB) {
4011 (void) bscv_get8(ssp, chan_general, EBUS_IDX_CBREAK_STATUS);
4012 }
4013
4014 if ((state_chng & EBUS_STATE_TEMPERATURE) &&
4015 ((dev_no - 1) < MAX_TEMPS)) {
4016 temp = bscv_get8(ssp, chan_general,
4017 EBUS_IDX_TEMP1 + dev_no - 1);
4018 /*
4019 * Only remember temperatures which are real values or
4020 * a NOT PRESENT value.
4021 */
4022 if ((temp <= LOM_TEMP_MAX_VALUE) ||
4023 (temp == LOM_TEMP_STATE_NOT_PRESENT)) {
4024 ssp->temps.temp[dev_no - 1] = temp;
4025 }
4026 }
4027
4028 if (state_chng & EBUS_STATE_RAIL) {
4029 (void) bscv_get8(ssp, chan_general, EBUS_IDX_SUPPLY_LO);
4030 (void) bscv_get8(ssp, chan_general, EBUS_IDX_SUPPLY_HI);
4031 }
4032 }
4033
4034 char *
4035 bscv_get_label(char labels[][MAX_LOM2_NAME_STR], int limit, int index)
4036 {
4037
4038 if (labels == NULL)
4039 return ("");
4040
4041 if (limit < 0 || index < 0 || index > limit)
4042 return ("-");
4043
4044 return (labels[index]);
4045 }
4046
4047 static void
4048 bscv_generic_sysevent(bscv_soft_state_t *ssp, char *class, char *subclass,
4049 char *fru_id, char *res_id, int32_t fru_state, char *msg)
4050 {
4051 int rv;
4052 nvlist_t *attr_list;
4053
4054 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent", "%s/%s:(%s,%s,%d) %s",
4055 class, subclass, fru_id, res_id, fru_state, msg);
4056
4057
4058 if (nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, KM_SLEEP)) {
4059 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent",
4060 "nvlist alloc failure");
4061 return;
4062 }
4063 if (nvlist_add_uint32(attr_list, ENV_VERSION, 1)) {
4064 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent",
4065 "nvlist ENV_VERSION failure");
4066 nvlist_free(attr_list);
4067 return;
4068 }
4069 if (nvlist_add_string(attr_list, ENV_FRU_ID, fru_id)) {
4070 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent",
4071 "nvlist ENV_FRU_ID failure");
4072 nvlist_free(attr_list);
4073 return;
4074 }
4075 if (nvlist_add_string(attr_list, ENV_FRU_RESOURCE_ID, res_id)) {
4076 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent",
4077 "nvlist ENV_FRU_RESOURCE_ID failure");
4078 nvlist_free(attr_list);
4079 return;
4080 }
4081 if (nvlist_add_string(attr_list, ENV_FRU_DEVICE, ENV_RESERVED_ATTR)) {
4082 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent",
4083 "nvlist ENV_FRU_DEVICE failure");
4084 nvlist_free(attr_list);
4085 return;
4086 }
4087 if (nvlist_add_int32(attr_list, ENV_FRU_STATE, fru_state)) {
4088 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent",
4089 "nvlist ENV_FRU_STATE failure");
4090 nvlist_free(attr_list);
4091 return;
4092 }
4093 if (nvlist_add_string(attr_list, ENV_MSG, msg)) {
4094 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent",
4095 "nvlist ENV_MSG failure");
4096 nvlist_free(attr_list);
4097 return;
4098 }
4099
4100 rv = ddi_log_sysevent(ssp->dip, DDI_VENDOR_SUNW, class,
4101 subclass, attr_list, NULL, DDI_SLEEP);
4102
4103 if (rv == DDI_SUCCESS) {
4104 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent", "sent sysevent");
4105 } else {
4106 cmn_err(CE_WARN, "!cannot deliver sysevent");
4107 }
4108
4109 nvlist_free(attr_list);
4110 }
4111
4112 /*
4113 * function - bscv_sysevent
4114 * description - send out a sysevent on the given change if needed
4115 * inputs - soft state pointer, event to report
4116 * outputs - none
4117 */
4118
4119 static void
4120 bscv_sysevent(bscv_soft_state_t *ssp, lom_event_t *event)
4121 {
4122 char *class = NULL;
4123 char *subclass = NULL;
4124 char *fru_id = "Blade"; /* The blade is only one FRU */
4125 char *res_id;
4126 int32_t fru_state = 0;
4127
4128 BSCV_TRACE(ssp, 'E', "bscv_sysevent", "processing event");
4129
4130 ASSERT(event != NULL);
4131
4132 /* Map ev_subsys to sysevent class/sub-class */
4133
4134 switch (EVENT_DECODE_SUBSYS(event->ev_subsys)) {
4135 case EVENT_SUBSYS_NONE:
4136 break;
4137 case EVENT_SUBSYS_ALARM:
4138 break;
4139 case EVENT_SUBSYS_TEMP:
4140 class = EC_ENV, subclass = ESC_ENV_TEMP;
4141 res_id = bscv_get_label(ssp->temps.name, ssp->temps.num,
4142 event->ev_resource - 1);
4143 switch (event->ev_event) {
4144 case EVENT_SEVERE_OVERHEAT:
4145 fru_state = ENV_FAILED;
4146 break;
4147 case EVENT_OVERHEAT:
4148 fru_state = ENV_WARNING;
4149 break;
4150 case EVENT_NO_OVERHEAT:
4151 fru_state = ENV_OK;
4152 break;
4153 default:
4154 return;
4155 }
4156 break;
4157 case EVENT_SUBSYS_OVERTEMP:
4158 break;
4159 case EVENT_SUBSYS_FAN:
4160 class = EC_ENV, subclass = ESC_ENV_FAN;
4161 res_id = bscv_get_label(ssp->fan_names, ssp->num_fans,
4162 event->ev_resource - 1);
4163 switch (event->ev_event) {
4164 case EVENT_FAILED:
4165 fru_state = ENV_FAILED;
4166 break;
4167 case EVENT_RECOVERED:
4168 fru_state = ENV_OK;
4169 break;
4170 default:
4171 return;
4172 }
4173 break;
4174 case EVENT_SUBSYS_SUPPLY:
4175 class = EC_ENV, subclass = ESC_ENV_POWER;
4176 res_id = bscv_get_label(ssp->sflags.name, ssp->sflags.num,
4177 event->ev_resource - 1);
4178 switch (event->ev_event) {
4179 case EVENT_FAILED:
4180 fru_state = ENV_FAILED;
4181 break;
4182 case EVENT_RECOVERED:
4183 fru_state = ENV_OK;
4184 break;
4185 default:
4186 return;
4187 }
4188 break;
4189 case EVENT_SUBSYS_BREAKER:
4190 break;
4191 case EVENT_SUBSYS_PSU:
4192 break;
4193 case EVENT_SUBSYS_USER:
4194 break;
4195 case EVENT_SUBSYS_PHONEHOME:
4196 break;
4197 case EVENT_SUBSYS_LOM:
4198 break;
4199 case EVENT_SUBSYS_HOST:
4200 break;
4201 case EVENT_SUBSYS_EVENTLOG:
4202 break;
4203 case EVENT_SUBSYS_EXTRA:
4204 break;
4205 case EVENT_SUBSYS_LED:
4206 if (event->ev_event != EVENT_FAULT_LED &&
4207 event->ev_event != EVENT_STATE_CHANGE)
4208 return;
4209 /*
4210 * There are 3 LEDs : Power, Service, Ready-to-Remove on a
4211 * JBOS blade. We'll never report the Power since Solaris
4212 * won't be running when it is _switched_ ON. Ready-to-Remove
4213 * will only be lit when we're powered down which also means
4214 * Solaris won't be running. We don't want to report it
4215 * during system testing / Sun VTS exercising the LEDs.
4216 *
4217 * Therefore, we only report the Service Required LED.
4218 */
4219 class = EC_ENV, subclass = ESC_ENV_LED;
4220 res_id = bscv_get_label(ssp->led_names, MAX_LED_ID,
4221 event->ev_resource - 1);
4222
4223 switch (event->ev_detail) {
4224 case LOM_LED_STATE_ON_STEADY:
4225 fru_state = ENV_LED_ON;
4226 break;
4227 case LOM_LED_STATE_ON_FLASHING:
4228 case LOM_LED_STATE_ON_SLOWFLASH:
4229 fru_state = ENV_LED_BLINKING;
4230 break;
4231 case LOM_LED_STATE_OFF:
4232 fru_state = ENV_LED_OFF;
4233 break;
4234 case LOM_LED_STATE_INACCESSIBLE:
4235 fru_state = ENV_LED_INACCESSIBLE;
4236 break;
4237 case LOM_LED_STATE_STANDBY:
4238 fru_state = ENV_LED_STANDBY;
4239 break;
4240 case LOM_LED_STATE_NOT_PRESENT:
4241 fru_state = ENV_LED_NOT_PRESENT;
4242 break;
4243 default:
4244 fru_state = ENV_LED_INACCESSIBLE;
4245 break;
4246 }
4247 break;
4248 default :
4249 break;
4250 }
4251
4252 if (class == NULL || subclass == NULL) {
4253 BSCV_TRACE(ssp, 'E', "bscv_sysevent", "class/subclass NULL");
4254 return;
4255 }
4256
4257 bscv_generic_sysevent(ssp, class, subclass, fru_id, res_id, fru_state,
4258 ENV_RESERVED_ATTR);
4259 }
4260
4261 /*
4262 * *********************************************************************
4263 * Firmware download (programming)
4264 * *********************************************************************
4265 */
4266
4267 /*
4268 * function - bscv_prog
4269 * description - LOMlite2 flash programming code.
4270 *
4271 * bscv_prog_image - download a complete image to the lom.
4272 * bscv_prog_receive_image - receive data to build up a
4273 * complete image.
4274 * bscv_prog_stop_lom - pause the event daemon and prepare
4275 * lom for firmware upgrade.
4276 * bscv_prog_start_lom - reinit the driver/lom after upgrade
4277 * and restart the event daemon
4278 *
4279 * inputs - soft state pointer, arg ptr, ioctl mode
4280 * outputs - status
4281 */
4282
4283 static int
4284 bscv_prog(bscv_soft_state_t *ssp, intptr_t arg, int mode)
4285 {
4286 lom_prog_t *prog;
4287 int res = 0;
4288
4289 /*
4290 * We will get repeatedly called with bits of data first for
4291 * loader, then for main image.
4292 */
4293 prog = (lom_prog_t *)kmem_alloc(sizeof (lom_prog_t), KM_SLEEP);
4294
4295 if (ddi_copyin((caddr_t)arg, (caddr_t)prog, sizeof (*prog),
4296 mode) < 0) {
4297 kmem_free((void *)prog, sizeof (*prog));
4298 return (EFAULT);
4299 }
4300
4301 BSCV_TRACE(ssp, 'U', "bscv_prog",
4302 "index 0x%x size 0x%x", prog->index, prog->size);
4303
4304 mutex_enter(&ssp->prog_mu);
4305 if (prog->size == 0) {
4306 if (prog->index == 2) {
4307 /*
4308 * This is the initial request for the chip type so we
4309 * know what we are programming.
4310 * The type will have been read in at init so just
4311 * return it in data[0].
4312 */
4313 prog->data[0] = bscv_get8_cached(ssp,
4314 EBUS_IDX_CPU_IDENT);
4315
4316 if (ddi_copyout((caddr_t)prog, (caddr_t)arg,
4317 sizeof (lom_prog_t), mode) < 0) {
4318 res = EFAULT;
4319 }
4320 } else if (prog->index == 0) {
4321 res = bscv_prog_stop_lom(ssp);
4322 } else if (prog->index == 1) {
4323 res = bscv_prog_start_lom(ssp);
4324 } else {
4325 res = EINVAL;
4326 }
4327 } else {
4328 if (ssp->image == NULL) {
4329 ssp->image = (uint8_t *)kmem_zalloc(
4330 BSC_IMAGE_MAX_SIZE, KM_SLEEP);
4331 }
4332 res = bscv_prog_receive_image(ssp, prog,
4333 ssp->image, BSC_IMAGE_MAX_SIZE);
4334 }
4335 mutex_exit(&ssp->prog_mu);
4336 kmem_free((void *)prog, sizeof (lom_prog_t));
4337
4338 return (res);
4339 }
4340
4341 static int
4342 bscv_check_loader_config(bscv_soft_state_t *ssp, boolean_t is_image2)
4343 {
4344 BSCV_TRACE(ssp, 'U', "bscv_check_loader_config",
4345 "loader_running %d, is_image2 %d",
4346 ssp->loader_running, is_image2);
4347
4348 /*
4349 * loader_running TRUE means that we have told the microcontroller to
4350 * JUMP into the loader code which has been downloaded into its RAM.
4351 * At this point its an error to try and download another loader. We
4352 * should be downloading the actual image at this point.
4353 * Conversely, it is an error to download an image when the loader is
4354 * not already downloaded and the microcontroller hasn't JUMPed into it.
4355 * is_image2 TRUE means the image is being downloaded.
4356 * is_image2 FALSE means the loader is being downloaded.
4357 */
4358 if (ssp->loader_running && !is_image2) {
4359 cmn_err(CE_WARN, "Attempt to download loader image "
4360 "with loader image already active");
4361 cmn_err(CE_CONT, "This maybe an attempt to restart a "
4362 "failed firmware download - ignoring download attempt");
4363 return (B_FALSE);
4364 } else if (!ssp->loader_running && is_image2) {
4365 cmn_err(CE_WARN, "Attempt to download firmware image "
4366 "without loader image active");
4367 return (B_FALSE);
4368
4369 }
4370
4371 return (B_TRUE);
4372 }
4373
4374 static uint32_t
4375 bscv_get_pagesize(bscv_soft_state_t *ssp)
4376 {
4377 uint32_t pagesize;
4378
4379 ASSERT(bscv_held(ssp));
4380
4381 pagesize = bscv_get32(ssp, chan_prog,
4382 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PAGE0));
4383
4384 BSCV_TRACE(ssp, 'U', "bscv_get_pagesize", "pagesize 0x%x", pagesize);
4385
4386 return (pagesize);
4387 }
4388
4389 /*
4390 * Sets the pagesize, returning the old value.
4391 */
4392 static uint32_t
4393 bscv_set_pagesize(bscv_soft_state_t *ssp, uint32_t pagesize)
4394 {
4395 uint32_t old_pagesize;
4396
4397 ASSERT(bscv_held(ssp));
4398
4399 old_pagesize = bscv_get_pagesize(ssp);
4400
4401 /*
4402 * The microcontroller remembers this value until until someone
4403 * changes it.
4404 */
4405 bscv_put32(ssp, chan_prog,
4406 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PSIZ0), pagesize);
4407
4408 return (old_pagesize);
4409 }
4410
4411 static uint8_t
4412 bscv_enter_programming_mode(bscv_soft_state_t *ssp)
4413 {
4414 uint8_t retval;
4415
4416 ASSERT(bscv_held(ssp));
4417
4418 bscv_put8(ssp, chan_prog,
4419 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR),
4420 EBUS_PROGRAM_PCR_PRGMODE_ON);
4421
4422 retval = bscv_get8(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM,
4423 EBUS_PROGRAM_PCSR));
4424
4425 return (retval);
4426 }
4427
4428 static void
4429 bscv_leave_programming_mode(bscv_soft_state_t *ssp, boolean_t with_jmp)
4430 {
4431 uint8_t reg;
4432 ASSERT(bscv_held(ssp));
4433
4434 if (with_jmp) {
4435 reg = EBUS_PROGRAM_PCR_PROGOFF_JUMPTOADDR;
4436 BSCV_TRACE(ssp, 'U', "bscv_leave_programming_mode",
4437 "jumptoaddr");
4438 } else {
4439 reg = EBUS_PROGRAM_PCR_PRGMODE_OFF;
4440 BSCV_TRACE(ssp, 'U', "bscv_leave_programming_mode",
4441 "prgmode_off");
4442 }
4443
4444 bscv_put8(ssp, chan_prog,
4445 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR), reg);
4446 }
4447
4448
4449 static void
4450 bscv_set_jump_to_addr(bscv_soft_state_t *ssp, uint32_t loadaddr)
4451 {
4452 ASSERT(bscv_held(ssp));
4453
4454 bscv_put32(ssp, chan_prog,
4455 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PADR0), loadaddr);
4456
4457 BSCV_TRACE(ssp, 'U', "bscv_set_jump_to_addr",
4458 "set jump to loadaddr 0x%x", loadaddr);
4459 }
4460
4461 static uint8_t
4462 bscv_erase_once(bscv_soft_state_t *ssp, uint32_t loadaddr, uint32_t image_size)
4463 {
4464 uint8_t retval;
4465
4466 ASSERT(bscv_held(ssp));
4467
4468 /*
4469 * write PADR, PSIZ to define area to be erased
4470 * We do not send erase for zero size because the current
4471 * downloader gets this wrong
4472 */
4473
4474 /*
4475 * start at 0
4476 */
4477 BSCV_TRACE(ssp, 'U', "bscv_erase_once", "sending erase command");
4478
4479 bscv_put32(ssp, chan_prog,
4480 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PADR0),
4481 loadaddr);
4482
4483 /* set PSIZ to full size of image to be programmed */
4484 bscv_put32(ssp, chan_prog,
4485 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PSIZ0),
4486 image_size);
4487
4488 /* write ERASE to PCSR */
4489 bscv_put8(ssp, chan_prog,
4490 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR),
4491 EBUS_PROGRAM_PCR_ERASE);
4492
4493 /* read PCSR to check status */
4494 retval = bscv_get8(ssp, chan_prog,
4495 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR));
4496 return (retval);
4497 }
4498
4499 static uint8_t
4500 bscv_do_erase(bscv_soft_state_t *ssp, uint32_t loadaddr, uint32_t image_size,
4501 boolean_t is_image2)
4502 {
4503 int retryable = BSC_ERASE_RETRY_LIMIT;
4504 uint8_t retval;
4505
4506 while (retryable--) {
4507 retval = bscv_erase_once(ssp, loadaddr, image_size);
4508 if (PSR_SUCCESS(retval))
4509 break;
4510 else
4511 cmn_err(CE_WARN, "erase error 0x%x, attempt %d"
4512 ", base 0x%x, size 0x%x, %s image",
4513 retval, BSC_ERASE_RETRY_LIMIT - retryable,
4514 loadaddr, image_size,
4515 is_image2 ? "main" : "loader");
4516 }
4517
4518 return (retval);
4519 }
4520
4521 static uint8_t
4522 bscv_set_page(bscv_soft_state_t *ssp, uint32_t addr)
4523 {
4524 uint32_t retval;
4525 int retryable = BSC_PAGE_RETRY_LIMIT;
4526
4527 ASSERT(bscv_held(ssp));
4528
4529 while (retryable--) {
4530
4531 /*
4532 * Write the page address and read it back for confirmation.
4533 */
4534 bscv_put32(ssp, chan_prog,
4535 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PADR0),
4536 addr);
4537 retval = bscv_get32(ssp, chan_prog,
4538 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PADR0));
4539
4540 if (retval == addr)
4541 break;
4542 else {
4543 cmn_err(CE_WARN, "programmming error, attempt %d, "
4544 "set page 0x%x, read back 0x%x",
4545 BSC_PAGE_RETRY_LIMIT - retryable,
4546 addr, retval);
4547 }
4548 }
4549 return ((addr == retval) ? EBUS_PROGRAM_PSR_SUCCESS :
4550 EBUS_PROGRAM_PSR_INVALID_OPERATION);
4551 }
4552
4553 static uint8_t
4554 bscv_do_page_data_once(bscv_soft_state_t *ssp, uint32_t index,
4555 uint32_t image_size, uint32_t pagesize, uint8_t *imagep,
4556 uint16_t *calcd_chksum)
4557 {
4558 uint32_t size;
4559 uint16_t chksum;
4560 int i;
4561 uint8_t retval;
4562
4563 ASSERT(bscv_held(ssp));
4564
4565 BSCV_TRACE(ssp, 'P', "bscv_do_page_data_once", "index 0x%x", index);
4566
4567 /* write PSIZ bytes to PDAT */
4568 if (index + pagesize < image_size) {
4569 bscv_rep_rw8(ssp, chan_prog, imagep + index,
4570 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_DATA),
4571 pagesize, DDI_DEV_NO_AUTOINCR, B_TRUE /* write */);
4572 size = pagesize;
4573 } else {
4574 BSCV_TRACE(ssp, 'P', "bscv_do_page_once",
4575 "Sending last block, last 0x%x bytes",
4576 (image_size % pagesize));
4577 size = (image_size - index);
4578 bscv_rep_rw8(ssp, chan_prog, imagep + index,
4579 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_DATA),
4580 size, DDI_DEV_NO_AUTOINCR, B_TRUE /* write */);
4581 /* Now pad the rest of the page with zeros */
4582 for (i = size; i < pagesize; i++) {
4583 bscv_put8(ssp, chan_prog,
4584 BSCVA(EBUS_CMD_SPACE_PROGRAM,
4585 EBUS_PROGRAM_DATA),
4586 0);
4587 }
4588 }
4589
4590 /* write the checksum to PCSM */
4591 chksum = 0;
4592 for (i = 0; i < size; i++) {
4593 chksum = ((chksum << 3) | (chksum >> 13)) ^
4594 *(imagep + index + i);
4595 }
4596 /* Cope with non-pagesize sized bufers */
4597 for (; i < pagesize; i++) {
4598 chksum = ((chksum << 3) | (chksum >> 13)) ^ 0;
4599 }
4600 bscv_put16(ssp, chan_prog,
4601 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSM0), chksum);
4602
4603 bscv_put8(ssp, chan_prog,
4604 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR),
4605 EBUS_PROGRAM_PCR_PROGRAM);
4606
4607 retval = bscv_get8(ssp, chan_prog,
4608 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR));
4609
4610 *calcd_chksum = chksum;
4611 return (retval);
4612 }
4613
4614 static uint8_t bscv_do_page(bscv_soft_state_t *ssp, uint32_t loadaddr,
4615 uint32_t index, uint32_t image_size, uint32_t pagesize, uint8_t *imagep,
4616 boolean_t is_image2)
4617 {
4618 int retryable = BSC_PAGE_RETRY_LIMIT;
4619 uint8_t retval;
4620 uint16_t checksum;
4621
4622 BSCV_TRACE(ssp, 'P', "bscv_do_page", "index 0x%x", index);
4623
4624 while (retryable--) {
4625 /*
4626 * Set the page address (with retries). If this is not
4627 * successful, then there is no point carrying on and sending
4628 * the page's data since that could cause random memory
4629 * corruption in the microcontroller.
4630 */
4631 retval = bscv_set_page(ssp, loadaddr + index);
4632 if (!PSR_SUCCESS(retval)) {
4633 cmn_err(CE_WARN, "programming error 0x%x, "
4634 "could not setup page address 0x%x, %s image",
4635 retval, loadaddr + index,
4636 is_image2 ? "main" : "loader");
4637 break;
4638 }
4639
4640 /*
4641 * Send down the data for the page
4642 */
4643
4644 BSCV_TRACE(ssp, 'P', "bscv_do_page", "sending data for page");
4645
4646 retval = bscv_do_page_data_once(ssp, index, image_size,
4647 pagesize, imagep, &checksum);
4648 if (PSR_SUCCESS(retval))
4649 break;
4650 else
4651 cmn_err(CE_WARN, "programming error 0x%x,"
4652 " attempt %d, index 0x%x, checksum 0x%x, %s image",
4653 retval, BSC_PAGE_RETRY_LIMIT - retryable,
4654 index, checksum, is_image2 ? "main" : "loader");
4655 }
4656
4657 BSCV_TRACE(ssp, 'U', "bscv_do_page", "Returning 0x%x for index 0x%x,"
4658 " checksum 0x%x, %s image", retval, index, checksum,
4659 is_image2 ? "main" : "loader");
4660
4661 return (retval);
4662 }
4663
4664 static uint8_t
4665 bscv_do_pages(bscv_soft_state_t *ssp, uint32_t loadaddr, uint32_t image_size,
4666 uint32_t pagesize, uint8_t *imagep, boolean_t is_image2)
4667 {
4668 uint8_t retval;
4669 uint32_t index;
4670
4671 BSCV_TRACE(ssp, 'P', "bscv_do_pages", "entered");
4672
4673 for (index = 0; index < image_size; index += pagesize) {
4674 retval = bscv_do_page(ssp, loadaddr, index, image_size,
4675 pagesize, imagep, is_image2);
4676 if (bscv_faulty(ssp) || !PSR_SUCCESS(retval)) {
4677 BSCV_TRACE(ssp, 'U', "bscv_do_pages",
4678 "Failed to program lom (status 0x%x)", retval);
4679 break;
4680 }
4681 }
4682
4683 return (retval);
4684 }
4685
4686 static int
4687 bscv_prog_image(bscv_soft_state_t *ssp, boolean_t is_image2,
4688 uint8_t *imagep, int image_size, uint32_t loadaddr)
4689 {
4690 uint32_t pagesize;
4691 int res = 0;
4692 uint8_t retval;
4693
4694 BSCV_TRACE(ssp, 'U', "bscv_prog_image",
4695 "image 0x%x, imagep %p, size 0x%x",
4696 is_image2 ? 2 : 1, imagep, image_size);
4697
4698 if (!bscv_check_loader_config(ssp, is_image2))
4699 /*
4700 * Return no error to allow userland to continue on with
4701 * downloading the image.
4702 */
4703 return (0);
4704
4705 bscv_enter(ssp);
4706
4707 pagesize = bscv_get_pagesize(ssp);
4708
4709 retval = bscv_enter_programming_mode(ssp);
4710 if (bscv_faulty(ssp) || !PSR_PROG(retval)) {
4711 cmn_err(CE_WARN, "lom: Failed to enter program mode, error 0x%x"
4712 ", %s image", retval, is_image2 ? "main" : "loader");
4713 res = EIO;
4714 goto BSCV_PROG_IMAGE_END;
4715 }
4716 BSCV_TRACE(ssp, 'U', "bscv_prog_image", "entered programming mode");
4717
4718 /*
4719 * Only issue an erase if we are downloading the image. The loader
4720 * does not need this step.
4721 */
4722 if (is_image2 && (image_size != 0)) {
4723 retval = bscv_do_erase(ssp, loadaddr, image_size, is_image2);
4724 if (bscv_faulty(ssp) || !PSR_SUCCESS(retval)) {
4725 cmn_err(CE_WARN,
4726 "lom: Erase failed during programming, status 0x%x",
4727 retval);
4728 res = EIO;
4729 goto BSCV_PROG_IMAGE_END;
4730 } else {
4731 BSCV_TRACE(ssp, 'U', "bscv_prog_image",
4732 "erase complete - programming...");
4733
4734 }
4735 }
4736
4737 (void) bscv_set_pagesize(ssp, pagesize);
4738
4739 retval = bscv_do_pages(ssp, loadaddr, image_size, pagesize, imagep,
4740 is_image2);
4741 if (bscv_faulty(ssp) || !PSR_SUCCESS(retval)) {
4742 BSCV_TRACE(ssp, 'U', "bscv_prog_image",
4743 "Failed to program lom (status 0x%x)", retval);
4744 res = EIO;
4745 goto BSCV_PROG_IMAGE_END;
4746 }
4747
4748 BSCV_PROG_IMAGE_END:
4749 if (res == 0 && !is_image2) {
4750 /*
4751 * We've downloaded the loader successfully. Now make the
4752 * microcontroller jump to it.
4753 */
4754 bscv_set_jump_to_addr(ssp, loadaddr);
4755 ssp->loader_running = B_TRUE;
4756 bscv_leave_programming_mode(ssp, B_TRUE);
4757 } else {
4758 /*
4759 * We've just downloaded either the loader which failed, or
4760 * the image (which may or may not have been successful).
4761 */
4762 bscv_set_jump_to_addr(ssp, 0);
4763
4764 if (res != 0) {
4765 BSCV_TRACE(ssp, 'U', "bscv_prog_image",
4766 "got error 0x%x - leaving programming mode",
4767 res);
4768 cmn_err(CE_WARN, "programming error 0x%x, %s image",
4769 res, is_image2 ? "main" : "loader");
4770 } else {
4771 BSCV_TRACE(ssp, 'U', "bscv_prog_image",
4772 "programming complete - leaving programming mode");
4773 }
4774
4775 bscv_leave_programming_mode(ssp, B_FALSE);
4776 ssp->loader_running = B_FALSE;
4777 }
4778
4779 bscv_exit(ssp);
4780
4781 return (res);
4782 }
4783
4784
4785 static int
4786 bscv_prog_receive_image(bscv_soft_state_t *ssp, lom_prog_t *prog,
4787 uint8_t *imagep, int max_size)
4788 {
4789 int res = 0;
4790 uint_t size;
4791 int32_t loadaddr;
4792 lom_prog_data_t *prog_data;
4793
4794 if ((prog->index & 0x7FFF) != ssp->prog_index) {
4795 BSCV_TRACE(ssp, 'U', "bscv_prog_receive_image",
4796 "Got wrong buffer 0x%x, expected 0x%x",
4797 prog->index & 0x7fff, ssp->prog_index);
4798 return (EINVAL);
4799 }
4800
4801 /*
4802 * We want to get the whole image and then do the download.
4803 * It is assumed the device is now in programming mode.
4804 */
4805
4806 if ((prog->index & 0x7fff) == 0) {
4807 /* Starting a new image */
4808 ssp->image_ptr = 0;
4809 }
4810
4811 if ((ssp->image_ptr + prog->size) > max_size) {
4812 cmn_err(CE_WARN,
4813 "lom image exceeded maximum size: got 0x%x, maximum 0x%x",
4814 (ssp->image_ptr + prog->size), max_size);
4815 return (EFAULT);
4816 }
4817 bcopy(prog->data, &imagep[ssp->image_ptr], prog->size);
4818 ssp->image_ptr += prog->size;
4819
4820 ssp->prog_index++;
4821
4822 if (prog->index & 0x8000) {
4823 /*
4824 * OK we have the whole image so synch up and start download.
4825 */
4826 prog_data = (lom_prog_data_t *)imagep;
4827 if (prog_data->header.magic != PROG_MAGIC) {
4828 /* Old style programming data */
4829 /* Take care image may not fill all of structure */
4830
4831 /* sign extend loadaddr from 16 to 32 bits */
4832 loadaddr = (int16_t)((uint16_t)((imagep[2] << 8) +
4833 imagep[3]));
4834
4835 size = (imagep[0] << 8) + imagep[1];
4836 if (size != (ssp->image_ptr - 4)) {
4837 cmn_err(CE_WARN, "Image size mismatch:"
4838 " expected 0x%x, got 0x%x",
4839 size, (ssp->image_ptr - 1));
4840 }
4841
4842 res = bscv_prog_image(ssp,
4843 ssp->image2_processing,
4844 imagep + 4, ssp->image_ptr - 4, loadaddr);
4845
4846 /*
4847 * Done the loading so set the flag to say we are doing
4848 * the other image.
4849 */
4850 ssp->image2_processing = !ssp->image2_processing;
4851 } else if ((ssp->image_ptr < sizeof (*prog_data)) ||
4852 (prog_data->platform.bscv.size !=
4853 (ssp->image_ptr - sizeof (*prog_data)))) {
4854 /* Image too small for new style image */
4855 cmn_err(CE_WARN, "image too small");
4856 res = EINVAL;
4857 } else {
4858 /* New style programming image */
4859 switch (prog_data->platmagic) {
4860 case PROG_PLAT_BSCV_IMAGE:
4861 res = bscv_prog_image(ssp, B_TRUE,
4862 imagep + sizeof (*prog_data),
4863 prog_data->platform.bscv.size,
4864 prog_data->platform.bscv.loadaddr);
4865 ssp->image2_processing = B_FALSE;
4866 break;
4867 case PROG_PLAT_BSCV_LOADER:
4868 res = bscv_prog_image(ssp, B_FALSE,
4869 imagep + sizeof (*prog_data),
4870 prog_data->platform.bscv.size,
4871 prog_data->platform.bscv.loadaddr);
4872 ssp->image2_processing = B_TRUE;
4873 break;
4874 default:
4875 cmn_err(CE_WARN, "unknown platmagic 0x%x",
4876 prog_data->platmagic);
4877 res = EINVAL;
4878 break;
4879 }
4880 }
4881 ssp->prog_index = 0;
4882 ssp->image_ptr = 0;
4883 }
4884 return (res);
4885 }
4886
4887 static int
4888 bscv_prog_stop_lom(bscv_soft_state_t *ssp)
4889 {
4890 if (ssp->programming) {
4891 /*
4892 * Already programming - this may be a retry of a failed
4893 * programming attempt or just a software error!
4894 */
4895 goto queue_stopped;
4896 }
4897
4898 if (bscv_pause_event_daemon(ssp) == BSCV_FAILURE) {
4899 BSCV_TRACE(ssp, 'Q', "bscv_prog_stop_lom",
4900 "failed to pause event daemon thread");
4901 return (EAGAIN);
4902 }
4903
4904 bscv_enter(ssp);
4905
4906 ssp->programming = B_TRUE;
4907
4908 bscv_exit(ssp);
4909
4910 queue_stopped:
4911
4912 ssp->prog_index = 0;
4913 ssp->image2_processing = B_FALSE;
4914
4915 return (0);
4916 }
4917
4918 static int
4919 bscv_prog_start_lom(bscv_soft_state_t *ssp)
4920 {
4921 int res = 0;
4922
4923 if (!ssp->programming) {
4924 /* Not programming so this is not a valid command */
4925 return (EINVAL);
4926 }
4927
4928 if (ssp->image != NULL) {
4929 kmem_free((void *)ssp->image, BSC_IMAGE_MAX_SIZE);
4930 ssp->image = NULL;
4931 }
4932
4933 /*
4934 * OK we are out of reset now so:
4935 * Probe the firmware and set everything up.
4936 */
4937
4938 bscv_enter(ssp);
4939
4940 /* Explicit clear fault because things may have been mended now */
4941 bscv_clear_fault(ssp);
4942
4943 if (ssp->loader_running) {
4944 cmn_err(CE_WARN, "Firmware upgrade failed to exit loader - "
4945 "performing forced exit");
4946 /* Must try to restart the lom here. */
4947 /* Ensure prog mode entry to enable PRGMODE_OFF */
4948 bscv_put8(ssp, chan_prog,
4949 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR),
4950 EBUS_PROGRAM_PCR_PRGMODE_ON);
4951 bscv_put8(ssp, chan_prog,
4952 BSCVA(EBUS_CMD_SPACE_PROGRAM, EBUS_PROGRAM_PCSR),
4953 EBUS_PROGRAM_PCR_PRGMODE_OFF);
4954 ssp->loader_running = B_FALSE;
4955 /* give the lom chance to recover */
4956 delay(drv_usectohz(5000000)); /* 5 seconds */
4957 }
4958
4959 ssp->prog_mode_only = B_FALSE;
4960 ssp->programming = B_FALSE;
4961
4962 if (bscv_attach_common(ssp) == DDI_FAILURE) {
4963 ssp->prog_mode_only = B_TRUE;
4964 res = EIO;
4965 }
4966
4967 bscv_exit(ssp);
4968
4969 if (!ssp->prog_mode_only) {
4970 /*
4971 * Start the event thread after the queue has started
4972 *
4973 * Not sure if this is entirely correct because
4974 * the other code at the end of bscv_attach()
4975 * does not get run here.
4976 */
4977 bscv_start_event_daemon(ssp);
4978 bscv_resume_event_daemon(ssp);
4979 }
4980
4981 return (res);
4982 }
4983
4984
4985 /*
4986 * *********************************************************************
4987 * Attach processing
4988 * *********************************************************************
4989 */
4990
4991 /*
4992 * function - bscv_attach_common
4993 * description - this routine co-ordinates the initialisation of the
4994 * driver both at attach time and after firmware programming.
4995 * sequence - bscv_setup_capability - read LOMlite2 capabilities
4996 * bscv_probe_check - test comms and setup register cache
4997 * bscv_setup_hostname - sync stored name in lom with nodename.
4998 * bscv_setup_static_info - read device names etc.
4999 * bscv_setup_events - start event daemon etc.
5000 *
5001 * inputs - device information structure, DDI_ATTACH command
5002 * outputs - DDI_SUCCESS or DDI_FAILURE
5003 */
5004
5005 static int
5006 bscv_attach_common(bscv_soft_state_t *ssp)
5007 {
5008 ASSERT(bscv_held(ssp));
5009
5010 BSCV_TRACE(ssp, 'A', "bscv_attach_common:", "");
5011
5012 /*
5013 * Set the threshold for reporting messages to the console to
5014 * Warnings or higher.
5015 */
5016 ssp->reporting_level = 2;
5017
5018 /*
5019 * When the system is not running the Operating System, make
5020 * the microcontroller print event messages straight onto the
5021 * console.
5022 */
5023 ssp->serial_reporting = LOM_SER_EVENTS_DEF;
5024
5025 /* Setup capabilities */
5026 bscv_setup_capability(ssp);
5027
5028 if (bscv_probe_check(ssp) == DDI_FAILURE) {
5029 cmn_err(CE_WARN, "BSC chip not responding");
5030 /*
5031 * We want lom -G to talk to this driver upon broken firmware
5032 * so we prematurely return success here.
5033 */
5034 return (DDI_SUCCESS);
5035 }
5036
5037 bscv_setup_hostname(ssp);
5038 bscv_setup_static_info(ssp);
5039 bscv_setup_events(ssp);
5040
5041 #if defined(__i386) || defined(__amd64)
5042 bscv_inform_bsc(ssp, BSC_INFORM_ONLINE);
5043 #endif /* __i386 || __amd64 */
5044 /*
5045 * Watchdog configuration and CPU signatures are sent asynchronously
5046 * with respect to attach so only inform the BSC if we've already
5047 * sent the data in the past.
5048 */
5049
5050 if (ssp->progress & BSCV_WDOG_CFG)
5051 bscv_setup_watchdog(ssp);
5052
5053 #ifdef __sparc
5054 if (ssp->progress & BSCV_SIG_SENT)
5055 bscv_write_sig(ssp, ssp->last_sig);
5056 #endif /* __sparc */
5057
5058 return (DDI_SUCCESS);
5059 }
5060
5061 /*
5062 * function - bscv_cleanup
5063 * description - routine that does the necessary tidying up if the attach
5064 * request fails or the driver is to be detached.
5065 * If the event thread has been started we may fail to
5066 * stop it (because it is busy) so we fail the cleanup
5067 * and hence the detach. All other calls to bscv_cleanup
5068 * are done before the event daemon is started.
5069 * inputs - soft state structure address.
5070 * outputs - DDI_SUCCESS or DDI_FAILURE.
5071 */
5072
5073 static int
5074 bscv_cleanup(bscv_soft_state_t *ssp)
5075 {
5076 int instance;
5077 uint8_t bits2set;
5078 uint8_t bits2clear;
5079
5080 instance = ssp->instance;
5081
5082 if (ssp->progress & BSCV_LOCKS) {
5083 bscv_enter(ssp);
5084 }
5085
5086 if (ssp->progress & BSCV_THREAD) {
5087 if (bscv_stop_event_daemon(ssp) == DDI_FAILURE) {
5088 /* Fail the cleanup - may be able to cleanup later */
5089 if (ssp->progress & BSCV_LOCKS) {
5090 bscv_exit(ssp);
5091 }
5092 return (DDI_FAILURE);
5093 }
5094 }
5095
5096 if (ssp->progress & BSCV_NODES) {
5097 ddi_remove_minor_node(ssp->dip, NULL);
5098 }
5099
5100 if (ssp->progress & BSCV_MAPPED_REGS) {
5101 /*
5102 * switch back on serial event reporting - cover all configs.
5103 */
5104 bits2set = 0;
5105 bits2clear = 0;
5106 if (ssp->serial_reporting == LOM_SER_EVENTS_ON) {
5107 bits2clear |= EBUS_ALARM_NOEVENTS;
5108 } else if (ssp->serial_reporting == LOM_SER_EVENTS_OFF) {
5109 bits2set |= EBUS_ALARM_NOEVENTS;
5110 } else if (ssp->serial_reporting == LOM_SER_EVENTS_DEF) {
5111 bits2clear |= EBUS_ALARM_NOEVENTS;
5112 }
5113 bscv_setclear8_volatile(ssp, chan_general, EBUS_IDX_ALARM,
5114 bits2set, bits2clear);
5115
5116 /*
5117 * disable the reset function if we have enabled
5118 * it. We don't want any nasty surprises like system
5119 * rebooting unexpectedly. If we timeout on the busy
5120 * flag we just have to carry on.
5121 */
5122
5123 BSCV_TRACE(ssp, 'W', "bscv_cleanup",
5124 "bscv_cleanup - disable wdog");
5125 if (bscv_get8_cached(ssp, EBUS_IDX_WDOG_CTRL) &
5126 EBUS_WDOG_ENABLE) {
5127 bscv_setclear8(ssp, chan_general, EBUS_IDX_WDOG_CTRL,
5128 0, EBUS_WDOG_RST | EBUS_WDOG_ENABLE);
5129 }
5130 }
5131
5132 /*
5133 * unmap registers
5134 */
5135
5136 if (ssp->progress & BSCV_MAPPED_REGS) {
5137 bscv_unmap_regs(ssp);
5138 }
5139
5140 /*
5141 * release any memory allocated for mutexes and condition
5142 * variables before deallocating the structures containing them
5143 */
5144
5145 if (ssp->progress & BSCV_LOCKS) {
5146 bscv_exit(ssp);
5147 cv_destroy(&ssp->task_cv);
5148 cv_destroy(&ssp->task_evnt_cv);
5149 mutex_destroy(&ssp->task_mu);
5150 mutex_destroy(&ssp->prog_mu);
5151 mutex_destroy(&ssp->cmd_mutex);
5152 }
5153
5154 if (ssp->image != NULL) {
5155 kmem_free((void *)ssp->image, BSC_IMAGE_MAX_SIZE);
5156 }
5157
5158 #if defined(__i386) || defined(__amd64)
5159 bscv_watchdog_cyclic_remove(ssp);
5160 #endif /* __i386 || __amd64 */
5161 ddi_soft_state_free(bscv_statep, instance);
5162
5163 return (DDI_SUCCESS);
5164 }
5165
5166 /*
5167 * function - bscv_setup_capability
5168 * description - probe the lom find what capabilities are present for
5169 * us to use.
5170 * inputs - soft state ptr
5171 * outputs - returns DDI_SUCCESS or DDI_FAILURE
5172 */
5173 static void bscv_setup_capability(bscv_soft_state_t *ssp)
5174 {
5175 ASSERT(bscv_held(ssp));
5176
5177 if (ssp->prog_mode_only) {
5178 /* Turn off all capabilities */
5179 ssp->cap0 = 0;
5180 ssp->cap1 = 0;
5181 ssp->cap2 = 0;
5182 return;
5183 }
5184
5185 ssp->cap0 = bscv_get8(ssp, chan_general, EBUS_IDX_CAP0);
5186 ssp->cap1 = bscv_get8(ssp, chan_general, EBUS_IDX_CAP1);
5187 ssp->cap2 = bscv_get8(ssp, chan_general, EBUS_IDX_CAP2);
5188 if (!bscv_faulty(ssp)) {
5189 BSCV_TRACE(ssp, 'A', "bscv_setup_capability",
5190 "Capability flags cap0=0x%x cap1=0x%x, cap2=0x%x",
5191 ssp->cap0, ssp->cap1, ssp->cap2);
5192 } else {
5193 cmn_err(CE_WARN, "!Could not read capability flags");
5194 ssp->cap0 = 0; ssp->cap1 = 0; ssp->cap2 = 0;
5195 }
5196 }
5197
5198 /*
5199 * function - bscv_probe_check
5200 * description - probe the lom to check for correct operation
5201 * has a side effect of setting up the cached registers and
5202 * updates ssp->prog_mode_only.
5203 * inputs - soft state ptr
5204 * outputs - returns DDI_SUCCESS or DDI_FAILURE
5205 */
5206
5207 static int bscv_probe_check(bscv_soft_state_t *ssp)
5208 {
5209 int i;
5210 uint8_t probeval;
5211
5212 ASSERT(bscv_held(ssp));
5213
5214 BSCV_TRACE(ssp, 'A', "bscv_probe_check", "");
5215
5216 if (!ssp->prog_mode_only) {
5217 /*
5218 * Make sure probe location is OK so that we are
5219 * in sync.
5220 * We want to make sure that this is not faulty so we
5221 * do a bscv_clear_fault to clear any existing
5222 * fault records down.
5223 */
5224 bscv_clear_fault(ssp);
5225 probeval = bscv_get8(ssp, chan_general, EBUS_IDX_PROBEAA);
5226 if (bscv_faulty(ssp)) {
5227 ssp->prog_mode_only = B_TRUE;
5228 } else if (probeval != 0xAA) {
5229 BSCV_TRACE(ssp, 'A', "bscv_probe_check",
5230 "LOMlite out of sync");
5231
5232 /*
5233 * It may be that the LOMlite was out of
5234 * sync so lets try the read again.
5235 */
5236 probeval = bscv_get8(ssp, chan_general,
5237 EBUS_IDX_PROBEAA);
5238 if (bscv_faulty(ssp)) {
5239 BSCV_TRACE(ssp, 'A', "bscv_probe_check",
5240 "Init readAA1 failed");
5241 ssp->prog_mode_only = B_TRUE;
5242 } else if (probeval != 0xAA) {
5243 /*
5244 * OK that is twice we are out so I
5245 * guess the LOMlite is in trouble
5246 */
5247 BSCV_TRACE(ssp, 'A', "bscv_probe_check",
5248 "Init readAA probe failed - got 0x%x",
5249 probeval);
5250 ssp->prog_mode_only = B_TRUE;
5251 }
5252 }
5253 }
5254
5255 /*
5256 * Read in all page zero lom registers.
5257 * Read state change 1st so we dont miss anything and clear it.
5258 * Note: we discard the values because we rely on bscv_get8 to
5259 * setup the cache of register values.
5260 */
5261
5262 if (!ssp->prog_mode_only) {
5263 (void) bscv_get8(ssp, chan_general, EBUS_IDX_STATE_CHNG);
5264 if (bscv_faulty(ssp)) {
5265 BSCV_TRACE(ssp, 'A', "bscv_probe_check",
5266 "Read of state change register failed");
5267 ssp->prog_mode_only = B_TRUE;
5268 }
5269 }
5270
5271 if (!ssp->prog_mode_only) {
5272 for (i = 1; i < 0x80; i++) {
5273 switch (i) {
5274 case EBUS_IDX_STATE_CHNG:
5275 case EBUS_IDX_CMD_RES:
5276 case EBUS_IDX_HNAME_CHAR:
5277 /*
5278 * Should not read these - they have side
5279 * effects.
5280 */
5281 break;
5282 default:
5283 (void) bscv_get8(ssp, chan_general, i);
5284 break;
5285 }
5286 if (bscv_faulty(ssp)) {
5287 BSCV_TRACE(ssp, 'A', "bscv_probe_check",
5288 "Initial read or register %2x failed", i);
5289 ssp->prog_mode_only = B_TRUE;
5290 /* Might as well give up now! */
5291 break;
5292 }
5293 }
5294 }
5295
5296 /*
5297 * Check the probe keys so we know the lom is OK
5298 */
5299
5300 if (!ssp->prog_mode_only) {
5301 if ((bscv_get8_cached(ssp, EBUS_IDX_PROBE55) != 0x55) ||
5302 (bscv_get8_cached(ssp, EBUS_IDX_PROBEAA) != 0xAA)) {
5303
5304 BSCV_TRACE(ssp, 'A', "bscv_probe_check",
5305 "LOMlite Probe failed");
5306 for (i = 0; i < 0x8; i++) {
5307 BSCV_TRACE(ssp, 'A', "bscv_probe_check",
5308 "%2x %2x %2x %2x %2x %2x %2x %2x %2x "
5309 "%2x %2x %2x %2x %2x %2x %2x %2x %2x",
5310 bscv_get8_cached(ssp, i),
5311 bscv_get8_cached(ssp, i + 1),
5312 bscv_get8_cached(ssp, i + 2),
5313 bscv_get8_cached(ssp, i + 3),
5314 bscv_get8_cached(ssp, i + 4),
5315 bscv_get8_cached(ssp, i + 5),
5316 bscv_get8_cached(ssp, i + 6),
5317 bscv_get8_cached(ssp, i + 7),
5318 bscv_get8_cached(ssp, i + 8),
5319 bscv_get8_cached(ssp, i + 9),
5320 bscv_get8_cached(ssp, i + 10),
5321 bscv_get8_cached(ssp, i + 11),
5322 bscv_get8_cached(ssp, i + 12),
5323 bscv_get8_cached(ssp, i + 13),
5324 bscv_get8_cached(ssp, i + 14),
5325 bscv_get8_cached(ssp, i + 15));
5326 }
5327 ssp->prog_mode_only = B_TRUE;
5328 }
5329 }
5330
5331 return ((ssp->prog_mode_only == B_FALSE) ? DDI_SUCCESS : DDI_FAILURE);
5332 }
5333
5334 #ifdef __sparc
5335 /*
5336 * function - bscv_idi_set
5337 * description - bscv inter driver interface set function
5338 * inputs - structure which defines type of service required and data
5339 * ouputs - none
5340 *
5341 * This is the Entry Point function for the platmod driver. It works out which
5342 * X Bus channel ought to deliver the service requested.
5343 */
5344 void
5345 bscv_idi_set(struct bscv_idi_info info)
5346 {
5347 struct bscv_idi_callout *tbl;
5348 boolean_t retval;
5349
5350 ASSERT(bscv_idi_mgr.magic == BSCV_IDI_CALLOUT_MAGIC);
5351
5352 if (bscv_idi_mgr.tbl == NULL) {
5353 if (bscv_idi_err())
5354 cmn_err(CE_WARN, "!bscv_idi_set : cannot find "
5355 "bscv_callout_table");
5356 return;
5357 } else if (bscv_idi_mgr.valid_inst == (uint32_t)~0) {
5358 if (bscv_idi_err())
5359 /*
5360 * This error message can appear in the context of
5361 * another driver, say platmod or todblade. We want
5362 * to clearly indicate the culprit driver so put in
5363 * the driver name.
5364 */
5365 cmn_err(CE_WARN, "!bscv_idi_set : no valid "
5366 "driver instance of "
5367 MYNAME);
5368 return;
5369 }
5370
5371 tbl = bscv_idi_mgr.tbl;
5372
5373 while (tbl->type != BSCV_IDI_NULL) {
5374 if (tbl->type == info.type) {
5375 /*
5376 * We service the request with a valid instance number
5377 * for the driver.
5378 */
5379 retval = ((tbl->fn) (info));
5380
5381 /*
5382 * If the request was serviced, clear any accumulated
5383 * error counters so future warnings will be reported if
5384 * seen.
5385 */
5386 if (retval == B_TRUE)
5387 bscv_idi_clear_err();
5388 return;
5389 } else {
5390 tbl++;
5391 }
5392 }
5393
5394 if (bscv_idi_err())
5395 cmn_err(CE_WARN, "!bscv_idi_set : cannot match info.type %d",
5396 info.type);
5397 }
5398
5399 /*
5400 * function - bscv_nodename_set
5401 * description - notify the event thread that a nodename change has occurred.
5402 * inputs - data from client driver
5403 * outputs - none.
5404 * side-effects - the event thread will schedule an update to the lom firmware.
5405 */
5406 /*ARGSUSED*/
5407 static boolean_t
5408 bscv_nodename_set(struct bscv_idi_info info)
5409 {
5410 bscv_soft_state_t *ssp;
5411
5412 ssp = ddi_get_soft_state(bscv_statep, bscv_idi_mgr.valid_inst);
5413
5414 if (ssp == NULL) {
5415 if (bscv_idi_err())
5416 cmn_err(CE_WARN, "!blade_nodename_set: cannot get ssp");
5417 return (B_FALSE);
5418 }
5419
5420 /* Get a lock on the SSP, notify our change, then exit */
5421 mutex_enter(&ssp->task_mu);
5422 ssp->nodename_change = B_TRUE;
5423 cv_signal(&ssp->task_cv);
5424 mutex_exit(&ssp->task_mu);
5425
5426 return (B_TRUE);
5427 }
5428
5429 /*
5430 * function - bscv_sig_set
5431 * description - write a signature
5432 * inputs - data from client driver
5433 * outputs - none.
5434 */
5435 static boolean_t
5436 bscv_sig_set(struct bscv_idi_info info)
5437 {
5438 bscv_soft_state_t *ssp;
5439 bscv_sig_t sig;
5440
5441 ssp = ddi_get_soft_state(bscv_statep, bscv_idi_mgr.valid_inst);
5442
5443 if (ssp == NULL) {
5444 if (bscv_idi_err())
5445 cmn_err(CE_WARN, "!blade_nodename_set: cannot get ssp");
5446 return (B_FALSE);
5447 }
5448
5449 /* Service the request */
5450 bcopy(info.data, &sig, sizeof (sig));
5451 bscv_enter(ssp);
5452 bscv_write_sig(ssp, sig);
5453 bscv_exit(ssp);
5454
5455 return (B_TRUE);
5456 }
5457 #endif /* __sparc */
5458
5459 static void
5460 bscv_wdog_do_pat(bscv_soft_state_t *ssp)
5461 {
5462 uint8_t pat;
5463
5464 /*
5465 * The value of the dog pat is a sequence number which wraps around,
5466 * bounded by BSCV_WDOG_PAT_SEQ_MASK.
5467 */
5468 pat = ssp->pat_seq++;
5469 pat &= EBUS_WDOG_NB_PAT_SEQ_MASK;
5470
5471 /* Set top nibble to indicate a pat */
5472 pat |= EBUS_WDOG_NB_PAT;
5473
5474 /*
5475 * Now pat the dog. This exercises a special protocol in the
5476 * bus nexus that offers : non-blocking IO, and timely delivery,
5477 * callable from high-level interrupt context. The requirement
5478 * on us is that the channel is not shared for any other use.
5479 * This means for chan_wdogpat, nothing may use channel[chan].regs
5480 * or channel.[chan].handle.
5481 */
5482
5483 ddi_put8(ssp->channel[chan_wdogpat].handle,
5484 ssp->channel[chan_wdogpat].regs, pat);
5485
5486 BSCV_TRACE(ssp, 'W', "bscv_wdog_pat", "patted the dog with seq %d",
5487 pat);
5488 }
5489
5490 #ifdef __sparc
5491 /*
5492 * function - bscv_wdog_pat
5493 * description - pat the watchdog
5494 * inputs - data from client driver
5495 * outputs - none.
5496 */
5497 /*ARGSUSED*/
5498 static boolean_t
5499 bscv_wdog_pat(struct bscv_idi_info info)
5500 {
5501 /*
5502 * This function remembers if it has ever been called with the
5503 * configure option set.
5504 */
5505 bscv_soft_state_t *ssp;
5506
5507 ssp = ddi_get_soft_state(bscv_statep, bscv_idi_mgr.valid_inst);
5508
5509 if (ssp == NULL) {
5510 if (bscv_idi_err())
5511 cmn_err(CE_WARN, "!bscv_wdog_pat: cannot get ssp");
5512 return (B_FALSE);
5513 } else if (ssp->nchannels == 0) {
5514 /* Didn't manage to map handles so ddi_{get,put}* broken */
5515 if (bscv_idi_err())
5516 cmn_err(CE_WARN, "!bscv_wdog_pat: handle not mapped");
5517 return (B_FALSE);
5518 }
5519
5520 bscv_wdog_do_pat(ssp);
5521 return (B_TRUE);
5522 }
5523
5524 /*
5525 * function - bscv_wdog_cfg
5526 * description - configure the watchdog
5527 * inputs - data from client driver
5528 * outputs - none.
5529 */
5530 static boolean_t
5531 bscv_wdog_cfg(struct bscv_idi_info info)
5532 {
5533 bscv_soft_state_t *ssp;
5534
5535 ssp = ddi_get_soft_state(bscv_statep, bscv_idi_mgr.valid_inst);
5536
5537 if (ssp == NULL) {
5538 if (bscv_idi_err())
5539 cmn_err(CE_WARN, "!bscv_wdog_cfg: cannot get ssp");
5540 return (B_FALSE);
5541 } else if (ssp->nchannels == 0) {
5542 /* Didn't manage to map handles so ddi_{get,put}* broken */
5543 if (bscv_idi_err())
5544 cmn_err(CE_WARN, "!bscv_wdog_cfg: handle not mapped");
5545 return (B_FALSE);
5546 }
5547
5548 if (sizeof (bscv_wdog_t) != info.size) {
5549 BSCV_TRACE(ssp, 'W', "bscv_wdog_set", "data passed in is size"
5550 " %d instead of %d", info.size,
5551 sizeof (bscv_wdog_t));
5552 return (B_FALSE);
5553 }
5554
5555 BSCV_TRACE(ssp, 'W', "bscv_wdog_cfg", "enable_wdog %s, "
5556 "wdog_timeout_s %d, reset_system_on_timeout %s",
5557 ((bscv_wdog_t *)info.data)->enable_wdog ? "enabled" : "disabled",
5558 ((bscv_wdog_t *)info.data)->wdog_timeout_s,
5559 ((bscv_wdog_t *)info.data)->reset_system_on_timeout ? "yes" : "no");
5560 bscv_write_wdog_cfg(ssp,
5561 ((bscv_wdog_t *)info.data)->wdog_timeout_s,
5562 ((bscv_wdog_t *)info.data)->enable_wdog,
5563 ((bscv_wdog_t *)info.data)->reset_system_on_timeout);
5564 return (B_TRUE);
5565 }
5566 #endif /* __sparc */
5567
5568 static void
5569 bscv_write_wdog_cfg(bscv_soft_state_t *ssp,
5570 uint_t wdog_timeout_s,
5571 boolean_t enable_wdog,
5572 uint8_t reset_system_on_timeout)
5573 {
5574 uint8_t cfg = EBUS_WDOG_NB_CFG;
5575
5576 /*
5577 * Configure the timeout value (1 to 127 seconds).
5578 * Note that a policy is implemented at the bsc/ssp which bounds
5579 * the value further. The bounding here is to fit the timeout value
5580 * into the 7 bits the bsc uses.
5581 */
5582 if (wdog_timeout_s < 1)
5583 ssp->watchdog_timeout = 1;
5584 else if (wdog_timeout_s > 127)
5585 ssp->watchdog_timeout = 127;
5586 else
5587 ssp->watchdog_timeout = wdog_timeout_s;
5588
5589 /*
5590 * Configure the watchdog on or off.
5591 */
5592 if (enable_wdog)
5593 cfg |= EBUS_WDOG_NB_CFG_ENB;
5594 else
5595 cfg &= ~EBUS_WDOG_NB_CFG_ENB;
5596
5597 /*
5598 * Configure whether the microcontroller should reset the system when
5599 * the watchdog expires.
5600 */
5601 ssp->watchdog_reset_on_timeout = reset_system_on_timeout;
5602
5603 ddi_put8(ssp->channel[chan_wdogpat].handle,
5604 ssp->channel[chan_wdogpat].regs, cfg);
5605
5606 /* have the event daemon set the timeout value and whether to reset */
5607 ssp->watchdog_change = B_TRUE;
5608
5609 BSCV_TRACE(ssp, 'W', "bscv_wdog_cfg",
5610 "configured the dog with cfg 0x%x", cfg);
5611 }
5612
5613 /*
5614 * function - bscv_setup_watchdog
5615 * description - setup the bsc watchdog
5616 * inputs - soft state ptr
5617 * outputs -
5618 */
5619 static void bscv_setup_watchdog(bscv_soft_state_t *ssp)
5620 {
5621 uint8_t set = 0;
5622 uint8_t clear = 0;
5623 #ifdef __sparc
5624 extern int watchdog_activated;
5625 #endif /* __sparc */
5626
5627 ASSERT(bscv_held(ssp));
5628
5629 /* Set the timeout */
5630 bscv_put8(ssp, chan_general,
5631 EBUS_IDX_WDOG_TIME, ssp->watchdog_timeout);
5632
5633 /* Set whether to reset the system on timeout */
5634 if (ssp->watchdog_reset_on_timeout) {
5635 set |= EBUS_WDOG_RST;
5636 } else {
5637 clear |= EBUS_WDOG_RST;
5638 }
5639
5640 if (watchdog_activated) {
5641 set |= EBUS_WDOG_ENABLE;
5642 } else {
5643 clear |= EBUS_WDOG_ENABLE;
5644 }
5645
5646 /* Set other host defaults */
5647 clear |= (EBUS_WDOG_BREAK_DISABLE | EBUS_WDOG_AL3_FANPSU
5648 | EBUS_WDOG_AL3_WDOG);
5649
5650 bscv_setclear8_volatile(ssp, chan_general, EBUS_IDX_WDOG_CTRL,
5651 set, clear);
5652
5653 #if defined(__i386) || defined(__amd64)
5654 /* start the cyclic based watchdog patter */
5655 bscv_watchdog_cyclic_add(ssp);
5656 #endif /* __i386 || __amd64 */
5657 ssp->progress |= BSCV_WDOG_CFG;
5658 }
5659
5660
5661 /*
5662 * function - bscv_setup_hostname
5663 * description - setup the lom hostname if different from the nodename
5664 * inputs - soft state ptr
5665 * outputs - none
5666 */
5667
5668 static void bscv_setup_hostname(bscv_soft_state_t *ssp)
5669 {
5670 char host_nodename[128];
5671 char lom_nodename[128];
5672 size_t hostlen;
5673 size_t nodelen;
5674
5675 ASSERT(bscv_held(ssp));
5676
5677 /*
5678 * Check machine label is the same as the
5679 * system nodename.
5680 */
5681 (void) strncpy(host_nodename, utsname.nodename,
5682 sizeof (host_nodename));
5683
5684 /* read in lom hostname */
5685 bscv_read_hostname(ssp, lom_nodename);
5686
5687 /* Enforce null termination */
5688 host_nodename[sizeof (host_nodename) - 1] = '\0';
5689 lom_nodename[sizeof (lom_nodename) - 1] = '\0';
5690
5691 hostlen = (size_t)bscv_get8(ssp, chan_general, EBUS_IDX_HNAME_LENGTH);
5692 nodelen = (size_t)strlen(host_nodename);
5693 if ((nodelen > 0) &&
5694 ((hostlen != nodelen) || (strcmp((const char *)&lom_nodename,
5695 (const char *)&host_nodename)) ||
5696 (hostlen == 0))) {
5697 BSCV_TRACE(ssp, 'A', "bscv_setup_hostname",
5698 "nodename(%s,%d) != bsc label(%s,%d)",
5699 host_nodename, nodelen, lom_nodename, hostlen);
5700
5701 /* Write new label into LOM EEPROM */
5702 bscv_write_hostname(ssp,
5703 host_nodename,
5704 (uint8_t)strlen(host_nodename));
5705 }
5706
5707 ssp->progress |= BSCV_HOSTNAME_DONE;
5708 }
5709
5710 /*
5711 * function - bscv_read_hostname
5712 * description - read the current hostname from the lom
5713 * inputs - soft state pointer and buffer to store the hostname in.
5714 * outputs - none
5715 */
5716
5717 static void
5718 bscv_read_hostname(bscv_soft_state_t *ssp, char *lom_nodename)
5719 {
5720 int num_failures;
5721 boolean_t needretry;
5722 int length;
5723 int i;
5724
5725 ASSERT(bscv_held(ssp));
5726
5727 /*
5728 * We have a special failure case here because a retry of a read
5729 * causes data to be lost. Thus we handle the retries ourselves
5730 * and are also responsible for detemining if the lom is faulty
5731 */
5732 for (num_failures = 0;
5733 num_failures < BSC_FAILURE_RETRY_LIMIT;
5734 num_failures++) {
5735 bscv_clear_fault(ssp);
5736 length = bscv_get8(ssp, chan_general, EBUS_IDX_HNAME_LENGTH);
5737 if (bscv_faulty(ssp)) {
5738 needretry = 1;
5739 } else {
5740 needretry = 0;
5741 for (i = 0; i < length; i++) {
5742 lom_nodename[i] = bscv_get8_once(ssp,
5743 chan_general, EBUS_IDX_HNAME_CHAR);
5744 /* Retry on any error */
5745 if (bscv_retcode(ssp) != 0) {
5746 needretry = 1;
5747 break;
5748 }
5749 }
5750 /* null terminate for strcmp later */
5751 lom_nodename[length] = '\0';
5752 }
5753 if (!needretry) {
5754 break;
5755 }
5756 /* Force the nodename to be empty */
5757 lom_nodename[0] = '\0';
5758 }
5759
5760 if (needretry) {
5761 /* Failure - we ran out of retries */
5762 cmn_err(CE_WARN,
5763 "bscv_read_hostname: retried %d times, giving up",
5764 num_failures);
5765 ssp->had_fault = B_TRUE;
5766 } else if (num_failures > 0) {
5767 BSCV_TRACE(ssp, 'R', "bscv_read_hostname",
5768 "retried %d times, succeeded", num_failures);
5769 }
5770 }
5771
5772 /*
5773 * function - bscv_write_hostname
5774 * description - write a new hostname to the lom
5775 * inputs - soft state pointer, pointer to new name, name length
5776 * outputs - none
5777 */
5778 static void
5779 bscv_write_hostname(bscv_soft_state_t *ssp,
5780 char *host_nodename, uint8_t length)
5781 {
5782 int num_failures;
5783 boolean_t needretry;
5784 int i;
5785
5786 ASSERT(bscv_held(ssp));
5787
5788 /*
5789 * We have a special failure case here because a retry of a read
5790 * causes data to be lost. Thus we handle the retries ourselves
5791 * and are also responsible for detemining if the lom is faulty
5792 */
5793 for (num_failures = 0;
5794 num_failures < BSC_FAILURE_RETRY_LIMIT;
5795 num_failures++) {
5796 bscv_clear_fault(ssp);
5797 bscv_put8(ssp, chan_general, EBUS_IDX_HNAME_LENGTH, length);
5798 if (bscv_faulty(ssp)) {
5799 needretry = 1;
5800 } else {
5801 needretry = 0;
5802 for (i = 0; i < length; i++) {
5803 bscv_put8_once(ssp, chan_general,
5804 EBUS_IDX_HNAME_CHAR, host_nodename[i]);
5805 /* Retry on any error */
5806 if (bscv_retcode(ssp) != 0) {
5807 needretry = 1;
5808 break;
5809 }
5810 }
5811 }
5812 if (!needretry) {
5813 break;
5814 }
5815 }
5816
5817 if (needretry) {
5818 /* Failure - we ran out of retries */
5819 cmn_err(CE_WARN,
5820 "bscv_write_hostname: retried %d times, giving up",
5821 num_failures);
5822 ssp->had_fault = B_TRUE;
5823 } else if (num_failures > 0) {
5824 BSCV_TRACE(ssp, 'R', "bscv_write_hostname",
5825 "retried %d times, succeeded", num_failures);
5826 }
5827 }
5828
5829 /*
5830 * function - bscv_setup_static_info
5831 * description - read in static information from the lom at attach time.
5832 * inputs - soft state ptr
5833 * outputs - none
5834 */
5835
5836 static void
5837 bscv_setup_static_info(bscv_soft_state_t *ssp)
5838 {
5839 uint8_t addr_space_ptr;
5840 uint16_t mask;
5841 uint8_t fanspeed;
5842 int oldtemps[MAX_TEMPS];
5843 int8_t temp;
5844 int i;
5845
5846 ASSERT(bscv_held(ssp));
5847
5848 /*
5849 * Finally read in some static info like device names,
5850 * shutdown enabled, etc before the queue starts.
5851 */
5852
5853 /*
5854 * To get the volts static info we need address space 2
5855 */
5856 bzero(&ssp->volts, sizeof (lom_volts_t));
5857 ssp->volts.num = EBUS_CONFIG2_NSUPPLY_DEC(
5858 bscv_get8(ssp, chan_general, EBUS_IDX_CONFIG2));
5859 if (ssp->volts.num > MAX_VOLTS) {
5860 cmn_err(CE_WARN,
5861 "lom: firmware reported too many voltage lines. ");
5862 cmn_err(CE_CONT, "Reported %d, maximum is %d",
5863 ssp->volts.num, MAX_VOLTS);
5864 ssp->volts.num = MAX_VOLTS;
5865 }
5866
5867 BSCV_TRACE(ssp, 'A', "bscv_setup_static_info",
5868 "num volts %d", ssp->volts.num);
5869 (void) bscv_read_env_name(ssp,
5870 EBUS_CMD_SPACE2,
5871 EBUS_IDX2_SUPPLY_NAME_START,
5872 EBUS_IDX2_SUPPLY_NAME_END,
5873 ssp->volts.name,
5874 ssp->volts.num);
5875
5876 mask = bscv_get8(ssp, chan_general, BSCVA(EBUS_CMD_SPACE2,
5877 EBUS_IDX2_SUPPLY_FATAL_MASK1)) << 8;
5878 mask |= bscv_get8(ssp, chan_general, BSCVA(EBUS_CMD_SPACE2,
5879 EBUS_IDX2_SUPPLY_FATAL_MASK2));
5880
5881 for (i = 0; i < ssp->volts.num; i++) {
5882 ssp->volts.shutdown_enabled[i] =
5883 (((mask >> i) & 1) == 0) ? 0 : 1;
5884 }
5885
5886 /*
5887 * Get the temperature static info and populate initial temperatures.
5888 * Do not destroy old temperature values if the new value is not
5889 * known i.e. if the device is inaccessible.
5890 */
5891 bcopy(ssp->temps.temp, oldtemps, sizeof (oldtemps));
5892
5893 bzero(&ssp->temps, sizeof (lom_temp_t));
5894 ssp->temps.num = EBUS_CONFIG2_NTEMP_DEC(
5895 bscv_get8(ssp, chan_general, EBUS_IDX_CONFIG2));
5896 if (ssp->temps.num > MAX_TEMPS) {
5897 cmn_err(CE_WARN,
5898 "lom: firmware reported too many temperatures being "
5899 "monitored.");
5900 cmn_err(CE_CONT, "Reported %d, maximum is %d",
5901 ssp->temps.num, MAX_TEMPS);
5902 ssp->temps.num = MAX_TEMPS;
5903 }
5904 ssp->temps.num_ov = EBUS_CONFIG3_NOTEMP_DEC(
5905 bscv_get8(ssp, chan_general, EBUS_IDX_CONFIG3));
5906 if (ssp->temps.num_ov > MAX_TEMPS) {
5907 cmn_err(CE_WARN,
5908 "lom: firmware reported too many over temperatures being "
5909 "monitored.");
5910 cmn_err(CE_CONT, "Reported %d, maximum is %d",
5911 ssp->temps.num_ov, MAX_TEMPS);
5912 ssp->temps.num_ov = MAX_TEMPS;
5913 }
5914 BSCV_TRACE(ssp, 'A', "bscv_setup_static_info",
5915 "num temps %d, over temps %d",
5916 ssp->temps.num, ssp->temps.num_ov);
5917
5918 addr_space_ptr = bscv_read_env_name(ssp,
5919 EBUS_CMD_SPACE4,
5920 EBUS_IDX4_TEMP_NAME_START,
5921 EBUS_IDX4_TEMP_NAME_END,
5922 ssp->temps.name,
5923 ssp->temps.num);
5924
5925 for (i = 0; i < ssp->temps.num; i++) {
5926 ssp->temps.warning[i] = (int8_t)bscv_get8(ssp, chan_general,
5927 BSCVA(EBUS_CMD_SPACE4, EBUS_IDX4_TEMP_WARN1 + i));
5928
5929 /*
5930 * If shutdown is not enabled then set it as zero so
5931 * it is not displayed by the utility.
5932 */
5933 if ((bscv_get8(ssp, chan_general, BSCVA(EBUS_CMD_SPACE4,
5934 EBUS_IDX4_TEMP_FATAL_MASK)) >> i) & 0x01) {
5935 ssp->temps.shutdown[i] = (int8_t)bscv_get8(ssp,
5936 chan_general,
5937 BSCVA(EBUS_CMD_SPACE4, EBUS_IDX4_TEMP_SDOWN1 + i));
5938 } else {
5939 ssp->temps.shutdown[i] = 0;
5940 }
5941 }
5942
5943 for (i = 0; i < ssp->temps.num; i++) {
5944 temp = bscv_get8(ssp, chan_general, EBUS_IDX_TEMP1 + i);
5945 if ((temp <= LOM_TEMP_MAX_VALUE) ||
5946 (temp == LOM_TEMP_STATE_NOT_PRESENT)) {
5947 ssp->temps.temp[i] = temp;
5948 } else {
5949 /* New value is not known - use old value */
5950 ssp->temps.temp[i] = oldtemps[i];
5951 }
5952 }
5953
5954 /*
5955 * Check for and skip a single 0xff character between the
5956 * temperature and over temperature names
5957 */
5958 if (bscv_get8(ssp, chan_general,
5959 BSCVA(EBUS_CMD_SPACE4, addr_space_ptr)) == 0xff) {
5960 addr_space_ptr++;
5961 }
5962
5963 (void) bscv_read_env_name(ssp,
5964 EBUS_CMD_SPACE4,
5965 addr_space_ptr,
5966 EBUS_IDX4_TEMP_NAME_END,
5967 ssp->temps.name_ov,
5968 ssp->temps.num_ov);
5969
5970 /*
5971 * To get the CB static info we need address space 3
5972 */
5973 bzero(&ssp->sflags, sizeof (lom_sflags_t));
5974 ssp->sflags.num = EBUS_CONFIG3_NBREAKERS_DEC(bscv_get8(ssp,
5975 chan_general, EBUS_IDX_CONFIG3));
5976 if (ssp->sflags.num > MAX_STATS) {
5977 cmn_err(CE_WARN,
5978 "lom: firmware reported too many status flags.");
5979 cmn_err(CE_CONT,
5980 "Reported %d, maximum is %d",
5981 ssp->sflags.num, MAX_STATS);
5982 ssp->sflags.num = MAX_STATS;
5983 }
5984 BSCV_TRACE(ssp, 'A', "bscv_setup_static_info",
5985 "num sflags %d", ssp->sflags.num);
5986
5987 (void) bscv_read_env_name(ssp,
5988 EBUS_CMD_SPACE3,
5989 EBUS_IDX3_BREAKER_NAME_START,
5990 EBUS_IDX3_BREAKER_NAME_END,
5991 ssp->sflags.name,
5992 ssp->sflags.num);
5993
5994
5995 /*
5996 * To get the fan static info we need address space 5
5997 */
5998 ssp->num_fans = EBUS_CONFIG_NFAN_DEC(
5999 bscv_get8(ssp, chan_general, EBUS_IDX_CONFIG));
6000 if (ssp->num_fans > MAX_FANS) {
6001 cmn_err(CE_WARN,
6002 "lom: firmware reported too many fans. ");
6003 cmn_err(CE_CONT,
6004 "Reported %d, maximum is %d",
6005 ssp->num_fans, MAX_FANS);
6006 ssp->num_fans = MAX_FANS;
6007 }
6008
6009 for (i = 0; i < ssp->num_fans; i++) {
6010 fanspeed = bscv_get8(ssp, chan_general,
6011 EBUS_IDX_FAN1_SPEED + i);
6012 if ((fanspeed <= LOM_FAN_MAX_SPEED) ||
6013 (fanspeed == LOM_FAN_NOT_PRESENT)) {
6014 /*
6015 * Do not destroy previous values unless the
6016 * value is definitive.
6017 */
6018 ssp->fanspeed[i] = fanspeed;
6019 }
6020 }
6021
6022 BSCV_TRACE(ssp, 'A', "bscv_setup_static_info",
6023 "num fans %d", ssp->num_fans);
6024
6025 (void) bscv_read_env_name(ssp,
6026 EBUS_CMD_SPACE5,
6027 EBUS_IDX5_FAN_NAME_START,
6028 EBUS_IDX5_FAN_NAME_END,
6029 ssp->fan_names,
6030 ssp->num_fans);
6031
6032 /* Get led static information from address space 10 */
6033
6034 (void) bscv_read_env_name(ssp,
6035 EBUS_CMD_SPACE_LEDS,
6036 EBUS_IDX10_LED_NAME_START,
6037 EBUS_IDX10_LED_NAME_END,
6038 ssp->led_names,
6039 MAX_LED_ID);
6040 }
6041
6042 /*
6043 * function - bscv_read_env_name
6044 * description - read in static environment names
6045 * warning changes address space and the caller relies
6046 * on this behaviour.
6047 * inputs - soft state ptr, chosen address space,
6048 * start of name data, end of name data,
6049 * name storage, number of names.
6050 * outputs - next address for reading name data.
6051 */
6052
6053 static uint8_t
6054 bscv_read_env_name(bscv_soft_state_t *ssp,
6055 uint8_t addr_space,
6056 uint8_t addr_start,
6057 uint8_t addr_end,
6058 char namebuf[][MAX_LOM2_NAME_STR],
6059 int numnames)
6060 {
6061 int i;
6062 int nameidx;
6063 int namemax;
6064 unsigned int addr_space_ptr;
6065 uint8_t this_char;
6066
6067 ASSERT(bscv_held(ssp));
6068
6069 BSCV_TRACE(ssp, 'A', "bscv_read_env_name",
6070 "bscv_read_env_name, space %d, start 0x%x, end 0x%x, numnames %d",
6071 addr_space, addr_start, addr_end, numnames);
6072
6073 addr_space_ptr = addr_start;
6074
6075 for (i = 0; i < numnames; i++) {
6076 nameidx = 0;
6077 namemax = sizeof (namebuf[i]);
6078 bzero(namebuf[i], namemax);
6079
6080 while (addr_space_ptr <= addr_end) {
6081 /*
6082 * Read the current character.
6083 */
6084 this_char = bscv_get8(ssp, chan_general,
6085 BSCVA(addr_space, addr_space_ptr));
6086
6087 if (this_char == 0xff) {
6088 /*
6089 * Ran out of names - this must
6090 * be the end of the name.
6091 * This is really an error because
6092 * we have just seen either a non-NUL
6093 * terminated string or the number of
6094 * strings did not match what was
6095 * reported.
6096 */
6097 break;
6098 }
6099 /*
6100 * We increment the buffer pointer now so that
6101 * it is ready for the next read
6102 */
6103 addr_space_ptr++;
6104
6105 if (this_char == '\0') {
6106 /* Found end of string - done */
6107 break;
6108 }
6109 if (nameidx < (namemax - 1)) {
6110 /*
6111 * Buffer not full - record character
6112 * NOTE we always leave room for the NUL
6113 * terminator.
6114 */
6115 namebuf[i][nameidx++] = this_char;
6116 }
6117 }
6118 /* Ensure null termination */
6119 namebuf[i][nameidx] = '\0';
6120 }
6121 /* Clamp addr_space_ptr to 0xff because we return uint8_t */
6122 if (addr_space_ptr > 0xff) {
6123 addr_space_ptr = 0xff;
6124 }
6125 return (addr_space_ptr);
6126 }
6127
6128 /*
6129 * function - bscv_setup_events
6130 * description - initialise the event reporting code
6131 * inputs - soft state ptr
6132 * outputs - DDI_SUCCESS or DDI_FAILURE
6133 */
6134
6135 static void
6136 bscv_setup_events(bscv_soft_state_t *ssp)
6137 {
6138 uint8_t bits2set;
6139 uint8_t bits2clear;
6140
6141 ASSERT(bscv_held(ssp));
6142
6143 /*
6144 * deal with event reporting - cover all cases
6145 */
6146
6147 bits2set = 0;
6148 bits2clear = 0;
6149 if (ssp->serial_reporting == LOM_SER_EVENTS_ON) {
6150 bits2clear |= EBUS_ALARM_NOEVENTS;
6151 } else if (ssp->serial_reporting == LOM_SER_EVENTS_OFF) {
6152 bits2set |= EBUS_ALARM_NOEVENTS;
6153 } else if (ssp->serial_reporting == LOM_SER_EVENTS_DEF) {
6154 bits2set |= EBUS_ALARM_NOEVENTS;
6155 }
6156 bscv_setclear8_volatile(ssp, chan_general, EBUS_IDX_ALARM,
6157 bits2set, bits2clear);
6158 }
6159
6160 #ifdef __sparc
6161 /*
6162 * function - bscv_write_sig
6163 * description - write out a signature, taking care to deal with any strange
6164 * values for CPU ID
6165 * inputs - soft state ptr, signature
6166 * outputs - none
6167 */
6168 static void
6169 bscv_write_sig(bscv_soft_state_t *ssp, bscv_sig_t s)
6170 {
6171 ASSERT(bscv_held(ssp));
6172
6173 /* Upload the signature */
6174 bscv_put32(ssp, chan_cpusig,
6175 BSCVA(EBUS_CMD_SPACE_CPUSIG, EBUS_IDX11_CPU_SIG_MSB),
6176 s.sig_info.signature);
6177
6178 /*
6179 * We always write the CPU ID last because this tells the firmware
6180 * that the signature is fully uploaded and therefore to consume the
6181 * data. This is required since the signature is > 1 byte in size
6182 * and we transmit data in single bytes.
6183 */
6184 if (s.cpu == ~0) {
6185 /* ~0 means the signature applies to any CPU. */
6186 bscv_put8(ssp, chan_cpusig,
6187 BSCVA(EBUS_CMD_SPACE_CPUSIG, EBUS_IDX11_CPU_ID),
6188 EBUS_ANY_CPU_ID);
6189 } else {
6190 if (s.cpu > 255) {
6191 /*
6192 * The CPU ID supplied is unexpectedly large. Lets
6193 * just use the bottom bits, in case other high order
6194 * bits are being used for special meaning.
6195 */
6196 cmn_err(CE_WARN, "CPU Signature ID 0x%x > 255", s.cpu);
6197 s.cpu %= 256;
6198 cmn_err(CE_CONT, "using ID 0x%x instead ", s.cpu);
6199 }
6200 bscv_put8(ssp, chan_cpusig,
6201 BSCVA(EBUS_CMD_SPACE_CPUSIG, EBUS_IDX11_CPU_ID),
6202 (uint8_t)s.cpu);
6203 }
6204
6205 ssp->last_sig = s;
6206 ssp->progress |= BSCV_SIG_SENT;
6207 }
6208 #endif /* __sparc */
6209
6210 #if defined(__i386) || defined(__amd64)
6211
6212 /*
6213 * function - bscv_inform_bsc
6214 * description - inform bsc of driver state for logging purposes
6215 * inputs - driver soft state, state
6216 * outputs - none
6217 *
6218 */
6219 static void
6220 bscv_inform_bsc(bscv_soft_state_t *ssp, uint32_t state)
6221 {
6222 ASSERT(bscv_held(ssp));
6223
6224 BSCV_TRACE(ssp, 'X', "bscv_inform_bsc",
6225 "bscv_inform_bsc: state=%d", state);
6226
6227 bscv_put32(ssp, chan_general,
6228 BSCVA(EBUS_CMD_SPACE_CPUSIG, EBUS_IDX11_CPU_SIG_MSB), state);
6229 bscv_put8(ssp, chan_cpusig,
6230 BSCVA(EBUS_CMD_SPACE_CPUSIG, EBUS_IDX11_CPU_ID), EBUS_ANY_CPU_ID);
6231 }
6232
6233 /*
6234 * function - bscv_watchdog_pat_request
6235 * description - request a heartbeat pat
6236 * inputs - timeout value in seconds
6237 * outputs - none
6238 */
6239 static void
6240 bscv_watchdog_pat_request(void *arg)
6241 {
6242 bscv_soft_state_t *ssp = (bscv_soft_state_t *)arg;
6243
6244 bscv_wdog_do_pat(ssp);
6245 }
6246
6247 /*
6248 * function - bscv_watchdog_cfg_request
6249 * description - request configuration of the bsc hardware watchdog
6250 * inputs - new state (0=disabled, 1=enabled)
6251 * outputs - one if successful, zero if unsuccesful
6252 */
6253 static void
6254 bscv_watchdog_cfg_request(bscv_soft_state_t *ssp, uint8_t new_state)
6255 {
6256 ASSERT(new_state == WDOG_ON || new_state == WDOG_OFF);
6257
6258 watchdog_activated = new_state;
6259 BSCV_TRACE(ssp, 'X', "bscv_watchdog_cfg_request",
6260 "watchdog_activated=%d", watchdog_activated);
6261 bscv_write_wdog_cfg(ssp,
6262 bscv_watchdog_timeout_seconds,
6263 new_state,
6264 wdog_reset_on_timeout);
6265 }
6266
6267 /*
6268 * function - bscv_set_watchdog_timer
6269 * description - setup the heartbeat timeout value
6270 * inputs - timeout value in seconds
6271 * outputs - zero if the value was not changed
6272 * otherwise the current value
6273 */
6274 static uint_t
6275 bscv_set_watchdog_timer(bscv_soft_state_t *ssp, uint_t timeoutval)
6276 {
6277 BSCV_TRACE(ssp, 'X', "bscv_set_watchdog_timer:",
6278 "timeout=%d", timeoutval);
6279
6280 /*
6281 * We get started during bscv_attach only
6282 * if bscv_watchdog_enable is set.
6283 */
6284 if (bscv_watchdog_available && (!watchdog_activated ||
6285 (watchdog_activated &&
6286 (timeoutval != bscv_watchdog_timeout_seconds)))) {
6287 bscv_watchdog_timeout_seconds = timeoutval;
6288 bscv_watchdog_cfg_request(ssp, WDOG_ON);
6289 return (bscv_watchdog_timeout_seconds);
6290 }
6291 return (0);
6292 }
6293
6294 /*
6295 * function - bscv_clear_watchdog_timer
6296 * description - add the watchdog patter cyclic
6297 * inputs - driver soft state
6298 * outputs - value of watchdog timeout in seconds
6299 *
6300 * This function is a copy of the SPARC implementation
6301 * in the todblade clock driver.
6302 */
6303 static void
6304 bscv_clear_watchdog_timer(bscv_soft_state_t *ssp)
6305 {
6306 BSCV_TRACE(ssp, 'X', "bscv_clear_watchdog_timer", "");
6307
6308 if (bscv_watchdog_available && watchdog_activated) {
6309 bscv_watchdog_enable = 0;
6310 bscv_watchdog_cfg_request(ssp, WDOG_OFF);
6311 }
6312 }
6313
6314 /*
6315 * function - bscv_panic_callback
6316 * description - called when we panic so we can disabled the watchdog
6317 * inputs - driver soft state pointer
6318 * outputs - DDI_SUCCESS
6319 */
6320 /*ARGSUSED1*/
6321 static boolean_t
6322 bscv_panic_callback(void *arg, int code)
6323 {
6324 bscv_soft_state_t *ssp = (bscv_soft_state_t *)arg;
6325
6326 BSCV_TRACE(ssp, 'X', "bscv_panic_callback",
6327 "disabling watchdog");
6328
6329 bscv_clear_watchdog_timer(ssp);
6330 /*
6331 * We dont get interrupts during the panic callback. But bscbus
6332 * takes care of all this
6333 */
6334 bscv_full_stop(ssp);
6335 return (DDI_SUCCESS);
6336 }
6337
6338 /*
6339 * function - bscv_watchdog_cyclic_add
6340 * description - add the watchdog patter cyclic
6341 * inputs - driver soft state
6342 * outputs - none
6343 */
6344 static void
6345 bscv_watchdog_cyclic_add(bscv_soft_state_t *ssp)
6346 {
6347 if (ssp->periodic_id != NULL) {
6348 return;
6349 }
6350
6351 ssp->periodic_id = ddi_periodic_add(bscv_watchdog_pat_request, ssp,
6352 WATCHDOG_PAT_INTERVAL, DDI_IPL_10);
6353
6354 BSCV_TRACE(ssp, 'X', "bscv_watchdog_cyclic_add:",
6355 "cyclic added");
6356 }
6357
6358 /*
6359 * function - bscv_watchdog_cyclic_remove
6360 * description - remove the watchdog patter cyclic
6361 * inputs - soft state ptr
6362 * outputs - none
6363 */
6364 static void
6365 bscv_watchdog_cyclic_remove(bscv_soft_state_t *ssp)
6366 {
6367 if (ssp->periodic_id == NULL) {
6368 return;
6369 }
6370 ddi_periodic_delete(ssp->periodic_id);
6371 ssp->periodic_id = NULL;
6372 BSCV_TRACE(ssp, 'X', "bscv_watchdog_cyclic_remove:",
6373 "cyclic removed");
6374 }
6375 #endif /* __i386 || __amd64 */
6376
6377
6378 /*
6379 * General utility routines ...
6380 */
6381
6382 #ifdef DEBUG
6383
6384 static void
6385 bscv_trace(bscv_soft_state_t *ssp, char code, const char *caller,
6386 const char *fmt, ...)
6387 {
6388 char buf[256];
6389 char *p;
6390 va_list va;
6391
6392 if (ssp->debug & (1 << (code-'@'))) {
6393 p = buf;
6394 (void) snprintf(p, sizeof (buf) - (p - buf),
6395 "%s/%s: ", MYNAME, caller);
6396 p += strlen(p);
6397
6398 va_start(va, fmt);
6399 (void) vsnprintf(p, sizeof (buf) - (p - buf), fmt, va);
6400 va_end(va);
6401
6402 buf[sizeof (buf) - 1] = '\0';
6403 (void) strlog((short)ssp->majornum, (short)ssp->minornum, code,
6404 SL_TRACE, buf);
6405 }
6406 }
6407
6408 #else /* DEBUG */
6409
6410 _NOTE(ARGSUSED(0))
6411 static void
6412 bscv_trace(bscv_soft_state_t *ssp, char code, const char *caller,
6413 const char *fmt, ...)
6414 {
6415 }
6416
6417 #endif /* DEBUG */