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 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * Interface for Serengeti IOSRAM mailbox
29 * OS <-> SC communication protocol
30 */
31
32 #include <sys/types.h>
33 #include <sys/systm.h>
34 #include <sys/ddi.h>
35 #include <sys/sunddi.h>
36 #include <sys/kmem.h>
37 #include <sys/uadmin.h>
38 #include <sys/machsystm.h>
39 #include <sys/disp.h>
40 #include <sys/taskq.h>
41
42 #include <sys/sgevents.h>
43 #include <sys/sgsbbc_priv.h>
44 #include <sys/sgsbbc_iosram_priv.h>
45 #include <sys/sgsbbc_mailbox_priv.h>
46 #include <sys/plat_ecc_unum.h>
47 #include <sys/plat_ecc_dimm.h>
48 #include <sys/serengeti.h>
49 #include <sys/fm/util.h>
50 #include <sys/promif.h>
51 #include <sys/plat_datapath.h>
52
53 sbbc_mailbox_t *master_mbox = NULL;
54
55 /*
56 * Panic Shutdown event support
57 */
58 static kmutex_t panic_hdlr_lock;
59
60 /*
61 * The ID of the soft interrupt which triggers the bringing down of a Domain
62 * when a PANIC_SHUTDOWN event is received.
63 */
64 static ddi_softintr_t panic_softintr_id = 0;
65
66 static sg_panic_shutdown_t panic_payload;
67 static sbbc_msg_t panic_payload_msg;
68
69 /*
70 * A queue for making sure outgoing messages are in order as ScApp
71 * does not support interleaving messages.
72 */
73 static kcondvar_t outbox_queue;
74 static kmutex_t outbox_queue_lock;
75
76 /*
77 * Handle unsolicited capability message.
78 */
79 static plat_capability_data_t cap_payload;
80 static sbbc_msg_t cap_payload_msg;
81 static kmutex_t cap_msg_hdlr_lock;
82
83 /*
84 * Datapath error and fault messages arrive unsolicited. The message data
85 * is contained in a plat_datapath_info_t structure.
86 */
87 typedef struct {
88 uint8_t type; /* CDS, DX, CP */
89 uint8_t pad; /* for alignment */
90 uint16_t cpuid; /* Safari ID of base CPU */
91 uint32_t t_value; /* SERD timeout threshold (seconds) */
92 } plat_datapath_info_t;
93
94 /*
95 * Unsolicited datapath error messages are processed via a soft interrupt,
96 * triggered in unsolicited interrupt processing.
97 */
98 static ddi_softintr_t dp_softintr_id = 0;
99 static kmutex_t dp_hdlr_lock;
100
101 static plat_datapath_info_t dp_payload;
102 static sbbc_msg_t dp_payload_msg;
103
104 static char *dperrtype[] = {
105 DP_ERROR_CDS,
106 DP_ERROR_DX,
107 DP_ERROR_RP
108 };
109
110 /*
111 * Variable indicating if we are already processing requests.
112 * Setting this value must be protected by outbox_queue_lock.
113 */
114 static int outbox_busy = 0;
115
116 /*
117 * local stuff
118 */
119 static int sbbc_mbox_send_msg(sbbc_msg_t *, int, uint_t, time_t, clock_t);
120 static int sbbc_mbox_recv_msg();
121 static int mbox_write(struct sbbc_mbox_header *,
122 struct sbbc_fragment *, sbbc_msg_t *);
123 static int mbox_read(struct sbbc_mbox_header *, struct sbbc_fragment *,
124 sbbc_msg_t *);
125 static int mbox_has_free_space(struct sbbc_mbox_header *);
126 static void mbox_skip_next_msg(struct sbbc_mbox_header *);
127 static int mbox_read_header(uint32_t, struct sbbc_mbox_header *);
128 static void mbox_update_header(uint32_t, struct sbbc_mbox_header *);
129 static int mbox_read_frag(struct sbbc_mbox_header *, struct sbbc_fragment *);
130 static struct sbbc_msg_waiter *mbox_find_waiter(uint16_t, uint32_t);
131 static void wakeup_next(void);
132 static uint_t sbbc_panic_shutdown_handler(char *arg);
133 static uint_t sbbc_do_fast_shutdown(char *arg);
134 static void sbbc_mbox_post_reg(sbbc_softstate_t *softsp);
135 static uint_t cap_ecc_msg_handler(char *);
136 static uint_t sbbc_datapath_error_msg_handler(char *arg);
137 static uint_t sbbc_datapath_fault_msg_handler(char *arg);
138 static uint_t sbbc_dp_trans_event(char *arg);
139
140
141 /*
142 * Interrupt handlers
143 */
144 static int sbbc_mbox_msgin(void);
145 static int sbbc_mbox_msgout(void);
146 static int sbbc_mbox_spacein(void);
147 static int sbbc_mbox_spaceout(void);
148
149 /*
150 * ECC event mailbox message taskq and parameters
151 */
152 static taskq_t *sbbc_ecc_mbox_taskq = NULL;
153 static int sbbc_ecc_mbox_taskq_errs = 0;
154 static int sbbc_ecc_mbox_send_errs = 0;
155 static int sbbc_ecc_mbox_inval_errs = 0;
156 static int sbbc_ecc_mbox_other_errs = 0;
157 int sbbc_ecc_mbox_err_throttle = ECC_MBOX_TASKQ_ERR_THROTTLE;
158
159 /*
160 * Called when SBBC driver is loaded
161 * Initialise global mailbox stuff, etc
162 */
163 void
sbbc_mbox_init()164 sbbc_mbox_init()
165 {
166 int i;
167
168 master_mbox = kmem_zalloc(sizeof (sbbc_mailbox_t), KM_NOSLEEP);
169 if (master_mbox == NULL) {
170 cmn_err(CE_PANIC, "Can't allocate memory for mailbox\n");
171 }
172
173 /*
174 * mutex'es for the wait-lists
175 */
176 for (i = 0; i < SBBC_MBOX_MSG_TYPES; i++) {
177 mutex_init(&master_mbox->mbox_wait_lock[i],
178 NULL, MUTEX_DEFAULT, NULL);
179 master_mbox->mbox_wait_list[i] = NULL;
180 }
181
182 for (i = 0; i < SBBC_MBOX_MSG_TYPES; i++)
183 master_mbox->intrs[i] = NULL;
184
185 /*
186 * Two mailbox channels SC -> OS , read-only
187 * OS -> SC, read/write
188 */
189 master_mbox->mbox_in = kmem_zalloc(sizeof (sbbc_mbox_t), KM_NOSLEEP);
190 if (master_mbox->mbox_in == NULL) {
191 cmn_err(CE_PANIC,
192 "Can't allocate memory for inbound mailbox\n");
193 }
194
195 master_mbox->mbox_out = kmem_zalloc(sizeof (sbbc_mbox_t), KM_NOSLEEP);
196 if (master_mbox->mbox_out == NULL) {
197 cmn_err(CE_PANIC,
198 "Can't allocate memory for outbound mailbox\n");
199 }
200
201 mutex_init(&master_mbox->mbox_in->mb_lock, NULL,
202 MUTEX_DEFAULT, NULL);
203 mutex_init(&master_mbox->mbox_out->mb_lock, NULL,
204 MUTEX_DEFAULT, NULL);
205
206 /*
207 * Add PANIC_SHUTDOWN Event mutex
208 */
209 mutex_init(&panic_hdlr_lock, NULL, MUTEX_DEFAULT, NULL);
210
211 /* Initialize datapath error message handler mutex */
212 mutex_init(&dp_hdlr_lock, NULL, MUTEX_DEFAULT, NULL);
213
214 /* Initialize capability message handler event mutex */
215 mutex_init(&cap_msg_hdlr_lock, NULL, MUTEX_DEFAULT, NULL);
216
217 /*
218 * NOT USED YET
219 */
220 master_mbox->mbox_in->mb_type =
221 master_mbox->mbox_out->mb_type = 0;
222
223 cv_init(&outbox_queue, NULL, CV_DEFAULT, NULL);
224 mutex_init(&outbox_queue_lock, NULL, MUTEX_DEFAULT, NULL);
225
226 }
227
228 /*
229 * called when the SBBC driver is unloaded
230 */
231 void
sbbc_mbox_fini()232 sbbc_mbox_fini()
233 {
234 int i;
235 int err;
236
237 /*
238 * destroy ECC event mailbox taskq
239 */
240 if (sbbc_ecc_mbox_taskq != NULL) {
241 taskq_destroy(sbbc_ecc_mbox_taskq);
242 sbbc_ecc_mbox_taskq = NULL;
243 sbbc_ecc_mbox_taskq_errs = 0;
244 }
245
246 /*
247 * unregister interrupts
248 */
249 (void) iosram_unreg_intr(SBBC_MAILBOX_IN);
250 (void) iosram_unreg_intr(SBBC_MAILBOX_IN);
251 (void) iosram_unreg_intr(SBBC_MAILBOX_SPACE_IN);
252 (void) iosram_unreg_intr(SBBC_MAILBOX_SPACE_OUT);
253
254 /*
255 * Remove Panic Shutdown and Datapath Error event support.
256 *
257 * NOTE: If we have not added the soft interrupt handlers for these
258 * then we know that we have not registered the event handlers either.
259 */
260 if (panic_softintr_id != 0) {
261 ddi_remove_softintr(panic_softintr_id);
262
263 err = sbbc_mbox_unreg_intr(MBOX_EVENT_PANIC_SHUTDOWN,
264 sbbc_panic_shutdown_handler);
265 if (err != 0) {
266 cmn_err(CE_WARN, "Failed to unreg Panic Shutdown "
267 "handler. Err=%d", err);
268 }
269 }
270 if (dp_softintr_id != 0) {
271 ddi_remove_softintr(dp_softintr_id);
272
273 err = sbbc_mbox_unreg_intr(MBOX_EVENT_DP_ERROR,
274 sbbc_datapath_error_msg_handler);
275 err |= sbbc_mbox_unreg_intr(MBOX_EVENT_DP_FAULT,
276 sbbc_datapath_fault_msg_handler);
277 if (err != 0) {
278 cmn_err(CE_WARN, "Failed to unreg Datapath Error "
279 "handler. Err=%d", err);
280 }
281 }
282
283 /*
284 * destroy all its mutex'es, lists etc
285 */
286
287 /*
288 * mutex'es for the wait-lists
289 */
290 for (i = 0; i < SBBC_MBOX_MSG_TYPES; i++) {
291 mutex_destroy(&master_mbox->mbox_wait_lock[i]);
292 }
293
294 mutex_destroy(&master_mbox->mbox_in->mb_lock);
295 mutex_destroy(&master_mbox->mbox_out->mb_lock);
296
297 mutex_destroy(&panic_hdlr_lock);
298 mutex_destroy(&dp_hdlr_lock);
299
300 kmem_free(master_mbox->mbox_in, sizeof (sbbc_mbox_t));
301 kmem_free(master_mbox->mbox_out, sizeof (sbbc_mbox_t));
302 kmem_free(master_mbox, sizeof (sbbc_mailbox_t));
303
304 cv_destroy(&outbox_queue);
305 mutex_destroy(&outbox_queue_lock);
306
307 err = sbbc_mbox_unreg_intr(INFO_MBOX, cap_ecc_msg_handler);
308 if (err != 0) {
309 cmn_err(CE_WARN, "Failed to unregister capability message "
310 "handler. Err=%d", err);
311 }
312
313 mutex_destroy(&cap_msg_hdlr_lock);
314 }
315
316 /*
317 * Update iosram_sbbc to the new softstate after a tunnel switch.
318 * Move software interrupts from the old dip to the new dip.
319 */
320 int
sbbc_mbox_switch(sbbc_softstate_t * softsp)321 sbbc_mbox_switch(sbbc_softstate_t *softsp)
322 {
323 sbbc_intrs_t *intr;
324 int msg_type;
325 int rc = 0;
326 int err;
327
328 if (master_mbox == NULL)
329 return (ENXIO);
330
331 ASSERT(MUTEX_HELD(&master_iosram->iosram_lock));
332
333 for (msg_type = 0; msg_type < SBBC_MBOX_MSG_TYPES; msg_type++) {
334
335 for (intr = master_mbox->intrs[msg_type]; intr != NULL;
336 intr = intr->sbbc_intr_next) {
337
338 if (intr->sbbc_intr_id) {
339 ddi_remove_softintr(intr->sbbc_intr_id);
340
341 if (ddi_add_softintr(softsp->dip,
342 DDI_SOFTINT_HIGH,
343 &intr->sbbc_intr_id, NULL, NULL,
344 intr->sbbc_handler, intr->sbbc_arg)
345 != DDI_SUCCESS) {
346
347 cmn_err(CE_WARN,
348 "Can't add SBBC mailbox "
349 "softint for msg_type %x\n",
350 msg_type);
351 rc = ENXIO;
352 }
353 }
354 }
355 }
356
357 /*
358 * Add PANIC_SHUTDOWN Event handler
359 */
360 if (panic_softintr_id) {
361 ddi_remove_softintr(panic_softintr_id);
362
363 err = ddi_add_softintr(softsp->dip, DDI_SOFTINT_LOW,
364 &panic_softintr_id, NULL, NULL,
365 sbbc_do_fast_shutdown, NULL);
366
367 if (err != DDI_SUCCESS) {
368 cmn_err(CE_WARN, "Failed to register Panic "
369 "Shutdown handler. Err=%d", err);
370 (void) sbbc_mbox_unreg_intr(MBOX_EVENT_PANIC_SHUTDOWN,
371 sbbc_panic_shutdown_handler);
372 rc = ENXIO;
373 }
374
375 }
376 /*
377 * Add Datapath Error Event handler
378 */
379 if (dp_softintr_id) {
380 ddi_remove_softintr(dp_softintr_id);
381
382 err = ddi_add_softintr(softsp->dip, DDI_SOFTINT_LOW,
383 &dp_softintr_id, NULL, NULL,
384 sbbc_dp_trans_event, NULL);
385
386 if (err != DDI_SUCCESS) {
387 cmn_err(CE_WARN, "Failed to register Datapath "
388 "Error Event handler. Err=%d", err);
389 (void) sbbc_mbox_unreg_intr(MBOX_EVENT_DP_ERROR,
390 sbbc_datapath_error_msg_handler);
391 (void) sbbc_mbox_unreg_intr(MBOX_EVENT_DP_FAULT,
392 sbbc_datapath_fault_msg_handler);
393 rc = ENXIO;
394 }
395
396 }
397
398 return (rc);
399 }
400
401 /*
402 * Called when the IOSRAM tunnel is created for the 'chosen' node.
403 *
404 * Read the mailbox header from the IOSRAM
405 * tunnel[SBBC_MAILBOX_KEY]
406 * Register the mailbox interrupt handlers
407 * for messages in/space etc
408 */
409 int
sbbc_mbox_create(sbbc_softstate_t * softsp)410 sbbc_mbox_create(sbbc_softstate_t *softsp)
411 {
412 struct sbbc_mbox_header header;
413
414 int i;
415 int err;
416 int rc = 0;
417
418 /*
419 * This function should only be called once when
420 * the chosen node is initialized.
421 */
422 ASSERT(MUTEX_HELD(&chosen_lock));
423
424 if (master_mbox == NULL)
425 return (ENXIO);
426
427 /*
428 * read the header at offset 0
429 * check magic/version etc
430 */
431 if (rc = iosram_read(SBBC_MAILBOX_KEY, 0, (caddr_t)&header,
432 sizeof (struct sbbc_mbox_header))) {
433
434 return (rc);
435 }
436
437 /*
438 * add the interrupt handlers for the mailbox
439 * interrupts
440 */
441 for (i = 0; i < MBOX_INTRS; i++) {
442 sbbc_intrfunc_t intr_handler;
443 uint_t *state;
444 kmutex_t *lock;
445 uint32_t intr_num;
446
447 switch (i) {
448 case MBOX_MSGIN_INTR:
449 intr_handler = (sbbc_intrfunc_t)sbbc_mbox_msgin;
450 intr_num = SBBC_MAILBOX_IN;
451 break;
452 case MBOX_MSGOUT_INTR:
453 intr_handler = (sbbc_intrfunc_t)sbbc_mbox_msgout;
454 intr_num = SBBC_MAILBOX_OUT;
455 break;
456 case MBOX_SPACEIN_INTR:
457 intr_handler = (sbbc_intrfunc_t)sbbc_mbox_spacein;
458 intr_num = SBBC_MAILBOX_SPACE_IN;
459 break;
460 case MBOX_SPACEOUT_INTR:
461 intr_handler = (sbbc_intrfunc_t)sbbc_mbox_spaceout;
462 intr_num = SBBC_MAILBOX_SPACE_OUT;
463 break;
464 }
465 state = (uint_t *)&master_mbox->intr_state[i].mbox_intr_state;
466 lock = &master_mbox->intr_state[i].mbox_intr_lock;
467 if (iosram_reg_intr(intr_num, intr_handler, (caddr_t)NULL,
468 state, lock)) {
469
470 cmn_err(CE_WARN,
471 "Can't register Mailbox interrupts \n");
472 }
473 }
474
475 /*
476 * Add PANIC_SHUTDOWN Event handler
477 */
478 panic_payload_msg.msg_buf = (caddr_t)&panic_payload;
479 panic_payload_msg.msg_len = sizeof (panic_payload);
480
481 err = ddi_add_softintr(softsp->dip, DDI_SOFTINT_LOW, &panic_softintr_id,
482 NULL, NULL, sbbc_do_fast_shutdown, NULL);
483
484 if (err == DDI_SUCCESS) {
485 err = sbbc_mbox_reg_intr(MBOX_EVENT_PANIC_SHUTDOWN,
486 sbbc_panic_shutdown_handler, &panic_payload_msg,
487 NULL, &panic_hdlr_lock);
488 if (err != 0) {
489 cmn_err(CE_WARN, "Failed to register Panic "
490 "Shutdown handler. Err=%d", err);
491 }
492
493 } else {
494 cmn_err(CE_WARN, "Failed to add Panic Shutdown "
495 "softintr handler");
496 }
497
498 /*
499 * Add Unsolicited Datapath Error Events handler
500 */
501 dp_payload_msg.msg_buf = (caddr_t)&dp_payload;
502 dp_payload_msg.msg_len = sizeof (dp_payload);
503
504 err = ddi_add_softintr(softsp->dip, DDI_SOFTINT_LOW, &dp_softintr_id,
505 NULL, NULL, sbbc_dp_trans_event, NULL);
506
507 if (err == DDI_SUCCESS) {
508 err = sbbc_mbox_reg_intr(MBOX_EVENT_DP_ERROR,
509 sbbc_datapath_error_msg_handler, &dp_payload_msg,
510 NULL, &dp_hdlr_lock);
511 err |= sbbc_mbox_reg_intr(MBOX_EVENT_DP_FAULT,
512 sbbc_datapath_fault_msg_handler, &dp_payload_msg,
513 NULL, &dp_hdlr_lock);
514 if (err != 0) {
515 cmn_err(CE_WARN, "Failed to register Datapath "
516 "error handler. Err=%d", err);
517 }
518
519 } else {
520 cmn_err(CE_WARN, "Failed to add Datapath error "
521 "softintr handler");
522 }
523
524 /*
525 * Register an interrupt handler with the sgbbc driver for the
526 * unsolicited INFO_MBOX response for the capability bitmap.
527 * This message is expected whenever the SC is (re)booted or
528 * failed over.
529 */
530 cap_payload_msg.msg_buf = (caddr_t)&cap_payload;
531 cap_payload_msg.msg_len = sizeof (cap_payload);
532
533 err = sbbc_mbox_reg_intr(INFO_MBOX, cap_ecc_msg_handler,
534 &cap_payload_msg, NULL, &cap_msg_hdlr_lock);
535 if (err != 0) {
536 cmn_err(CE_WARN, "Failed to register capability message"
537 " handler with Err=%d", err);
538 }
539
540 /*
541 * Now is the opportunity to register
542 * the deferred mbox intrs.
543 */
544 sbbc_mbox_post_reg(softsp);
545
546 return (rc);
547 }
548
549 /*
550 * Called when chosen IOSRAM is initialized
551 * to register the deferred mbox intrs.
552 */
553 static void
sbbc_mbox_post_reg(sbbc_softstate_t * softsp)554 sbbc_mbox_post_reg(sbbc_softstate_t *softsp)
555 {
556 uint32_t msg_type;
557 sbbc_intrs_t *intr;
558
559 ASSERT(master_mbox);
560 for (msg_type = 0; msg_type < SBBC_MBOX_MSG_TYPES; msg_type++) {
561 intr = master_mbox->intrs[msg_type];
562 while (intr != NULL) {
563 if (!intr->registered) {
564 SGSBBC_DBG_INTR(CE_CONT, "sbbc_mbox_post_reg: "
565 "postreg for msgtype=%x\n", msg_type);
566 if (ddi_add_softintr(softsp->dip,
567 DDI_SOFTINT_HIGH, &intr->sbbc_intr_id,
568 NULL, NULL, intr->sbbc_handler,
569 (caddr_t)intr->sbbc_arg)
570 != DDI_SUCCESS) {
571 cmn_err(CE_WARN, "Can't add SBBC "
572 "deferred mailbox softint \n");
573 } else
574 intr->registered = 1;
575 }
576 intr = intr->sbbc_intr_next;
577 }
578 }
579 }
580
581 /*
582 * Register a handler for a message type
583 * NB NB NB
584 * arg must be either NULL or the address of a sbbc_fragment
585 * pointer
586 */
587 int
sbbc_mbox_reg_intr(uint32_t msg_type,sbbc_intrfunc_t intr_handler,sbbc_msg_t * arg,uint_t * state,kmutex_t * lock)588 sbbc_mbox_reg_intr(uint32_t msg_type, sbbc_intrfunc_t intr_handler,
589 sbbc_msg_t *arg, uint_t *state, kmutex_t *lock)
590 {
591 sbbc_intrs_t *intr, *previntr;
592 int rc = 0;
593
594 /*
595 * Validate arguments
596 */
597 if (msg_type >= SBBC_MBOX_MSG_TYPES)
598 return (EINVAL);
599
600 /*
601 * Verify that we have already set up the master sbbc
602 */
603 if (master_iosram == NULL || master_mbox == NULL)
604 return (ENXIO);
605
606 mutex_enter(&master_iosram->iosram_lock);
607 msg_type &= SBBC_MSG_TYPE_MASK;
608 previntr = intr = master_mbox->intrs[msg_type];
609
610 /* Find the end of the link list */
611 while (intr != NULL && intr->sbbc_handler != intr_handler) {
612
613 previntr = intr;
614 intr = intr->sbbc_intr_next;
615 }
616
617 /* Return if the handler has been registered */
618 if (intr != NULL) {
619 mutex_exit(&master_iosram->iosram_lock);
620 return (EBUSY);
621 }
622
623 /*
624 * The requested handler has not been installed.
625 * Allocate some memory.
626 */
627 intr = kmem_zalloc(sizeof (sbbc_intrs_t), KM_SLEEP);
628
629 intr->sbbc_handler = intr_handler;
630 intr->sbbc_arg = (caddr_t)arg;
631 intr->sbbc_intr_state = state;
632 intr->sbbc_intr_lock = lock;
633 intr->sbbc_intr_next = NULL;
634 /* not registered yet */
635 intr->registered = 0;
636
637 if (previntr != NULL)
638 previntr->sbbc_intr_next = intr;
639 else
640 master_mbox->intrs[msg_type] = intr;
641
642 /*
643 * register only if the chosen IOSRAM is
644 * initialized, otherwise defer the registration
645 * until IOSRAM initialization.
646 */
647 if (master_iosram->iosram_sbbc) {
648 if (ddi_add_softintr(master_iosram->iosram_sbbc->dip,
649 DDI_SOFTINT_HIGH,
650 &intr->sbbc_intr_id, NULL, NULL,
651 intr_handler, (caddr_t)arg) != DDI_SUCCESS) {
652 cmn_err(CE_WARN, "Can't add SBBC mailbox softint \n");
653 rc = ENXIO;
654 } else
655 intr->registered = 1;
656 } else {
657 SGSBBC_DBG_INTR(CE_CONT, "sbbc_mbox_reg_intr: "
658 "deferring msg=%x registration\n", msg_type);
659 }
660
661 mutex_exit(&master_iosram->iosram_lock);
662
663 return (rc);
664 }
665
666 /*
667 * Unregister a handler for a message type
668 */
669 int
sbbc_mbox_unreg_intr(uint32_t msg_type,sbbc_intrfunc_t intr_handler)670 sbbc_mbox_unreg_intr(uint32_t msg_type, sbbc_intrfunc_t intr_handler)
671 {
672 sbbc_intrs_t *intr, *previntr, *nextintr;
673
674 /*
675 * Verify that we have already set up the master sbbc
676 */
677 if (master_iosram == NULL || master_mbox == NULL)
678 return (ENXIO);
679
680 msg_type &= SBBC_MSG_TYPE_MASK;
681
682 if (msg_type >= SBBC_MBOX_MSG_TYPES ||
683 intr_handler == (sbbc_intrfunc_t)NULL) {
684
685 return (EINVAL);
686 }
687
688 mutex_enter(&master_iosram->iosram_lock);
689
690 previntr = intr = master_mbox->intrs[msg_type];
691
692 /*
693 * No handlers installed
694 */
695 if (intr == NULL) {
696 mutex_exit(&master_iosram->iosram_lock);
697 return (EINVAL);
698 }
699
700 while (intr != NULL) {
701
702 /* Save the next pointer */
703 nextintr = intr->sbbc_intr_next;
704
705 /* Found a match. Remove it from the link list */
706 if (intr->sbbc_handler == intr_handler) {
707
708 if (intr->sbbc_intr_id)
709 ddi_remove_softintr(intr->sbbc_intr_id);
710
711 kmem_free(intr, sizeof (sbbc_intrs_t));
712
713 if (previntr != master_mbox->intrs[msg_type])
714 previntr->sbbc_intr_next = nextintr;
715 else
716 master_mbox->intrs[msg_type] = nextintr;
717
718 break;
719 }
720
721 /* update pointers */
722 previntr = intr;
723 intr = nextintr;
724 }
725
726 mutex_exit(&master_iosram->iosram_lock);
727
728 return (0);
729 }
730 /*
731 * Interrupt handlers - one for each mailbox
732 * interrupt type
733 */
734
735 /*
736 * mailbox message received
737 */
738 static int
sbbc_mbox_msgin()739 sbbc_mbox_msgin()
740 {
741 mutex_enter(&master_mbox->intr_state[MBOX_MSGIN_INTR].mbox_intr_lock);
742 master_mbox->intr_state[MBOX_MSGIN_INTR].mbox_intr_state =
743 SBBC_INTR_RUNNING;
744 mutex_exit(&master_mbox->intr_state[MBOX_MSGIN_INTR].mbox_intr_lock);
745
746 /*
747 * We are only locking the InBox here, not the whole
748 * mailbox. This is based on the assumption of
749 * complete separation of mailboxes - outbox is
750 * read/write, inbox is read-only.
751 * We only ever update the producer for the
752 * outbox and the consumer for the inbox.
753 */
754 mutex_enter(&master_mbox->mbox_in->mb_lock);
755
756 for (;;) {
757 /*
758 * Get as many incoming messages as possible
759 */
760 while (sbbc_mbox_recv_msg() == 0)
761 /* empty */;
762
763 /*
764 * send interrupt to SC to let it know that
765 * space is available over here
766 */
767 (void) iosram_send_intr(SBBC_MAILBOX_SPACE_IN);
768
769 mutex_enter(&master_mbox->intr_state[MBOX_MSGIN_INTR].
770 mbox_intr_lock);
771 /*
772 * Read the inbox one more time to see if new messages
773 * has come in after we exit the loop.
774 */
775 if (sbbc_mbox_recv_msg() == 0) {
776 mutex_exit(&master_mbox->intr_state[MBOX_MSGIN_INTR].
777 mbox_intr_lock);
778 } else {
779 master_mbox->intr_state[MBOX_MSGIN_INTR].
780 mbox_intr_state = SBBC_INTR_IDLE;
781 mutex_exit(&master_mbox->intr_state[MBOX_MSGIN_INTR].
782 mbox_intr_lock);
783 break;
784 }
785 }
786
787 mutex_exit(&master_mbox->mbox_in->mb_lock);
788
789 return (DDI_INTR_CLAIMED);
790 }
791
792 /*
793 * mailbox message sent
794 */
795 static int
sbbc_mbox_msgout()796 sbbc_mbox_msgout()
797 {
798 /*
799 * Should never get this
800 */
801
802 return (DDI_INTR_CLAIMED);
803 }
804
805 /*
806 * space in the inbox
807 */
808 static int
sbbc_mbox_spacein()809 sbbc_mbox_spacein()
810 {
811 /*
812 * Should never get this
813 */
814
815 return (DDI_INTR_CLAIMED);
816 }
817
818 /*
819 * space in the outbox
820 */
821 static int
sbbc_mbox_spaceout()822 sbbc_mbox_spaceout()
823 {
824 /*
825 * cv_broadcast() the threads waiting on the
826 * outbox's mb_full
827 */
828
829 mutex_enter(&master_mbox->mbox_out->mb_lock);
830
831 cv_broadcast(&master_mbox->mbox_out->mb_full);
832
833 mutex_exit(&master_mbox->mbox_out->mb_lock);
834
835 return (DDI_INTR_CLAIMED);
836 }
837
838 /*
839 * Client Interface
840 *
841 * The main interface will be
842 *
843 * sbbc_mbox_request_response(sbbc_msg_t *request,
844 * sbbc_msg_t *response, time_t wait_time)
845 *
846 * 1) the client calls request_response
847 * 2) a new unique msg ID is assigned for that msg
848 * 3) if there is space available in the outbox
849 * - the request msg is written to the mbox_out mailbox
850 * and the mailbox info updated.
851 * - allocate a sbbc_msg_waiter struct for this
852 * message, initialise the w_cv condvar.
853 * - get the mailbox mbox_wait_lock mutex for this
854 * message type
855 * - the response msg is put on the mbox_wait_list for
856 * that message type to await the SC's response
857 * - wait on the w_cv condvar protected by the
858 * mbox_wait_lock
859 * - SBBC_MAILBOX_OUT interrupt is sent to the SC
860 *
861 * 4) if no space in the outbox,
862 * - the request message blocks waiting
863 * for a SBBC_MAILBOX_SPACE_OUT interrupt
864 * It will block on the mailbox mb_full condvar.
865 * - go to (3) above
866 * 5) When we get a SBBC_MAILBOX_IN interrupt.
867 * - read the message ID of the next message (FIFO)
868 * - find that ID on the wait list
869 * - no wait list entry => unsolicited message. If theres
870 * a handler, trigger it
871 * - if someone is waiting, read the message in from
872 * SRAM, handling fragmentation, wraparound, etc
873 * - if the whole message has been read, signal
874 * the waiter
875 * - read next message until mailbox empty
876 * - send SBBC_MAILBOX_SPACE_IN interrupt to the SC
877 *
878 * 6) If a response is required and none is received, the client
879 * will timeout after <wait_time> seconds and the message
880 * status will be set to ETIMEDOUT.
881 */
882 int
sbbc_mbox_request_response(sbbc_msg_t * request,sbbc_msg_t * response,time_t wait_time)883 sbbc_mbox_request_response(sbbc_msg_t *request,
884 sbbc_msg_t *response, time_t wait_time)
885 {
886
887 struct sbbc_msg_waiter *waiter;
888 uint_t msg_id;
889 int rc = 0;
890 int flags;
891 uint16_t msg_type;
892 clock_t stop_time;
893 clock_t clockleft;
894 kmutex_t *mbox_wait_lock;
895 kmutex_t *mb_lock;
896 static fn_t f = "sbbc_mbox_request_response";
897
898 if ((request == NULL) ||
899 (request->msg_type.type >= SBBC_MBOX_MSG_TYPES) ||
900 ((response != NULL) &&
901 (response->msg_type.type >= SBBC_MBOX_MSG_TYPES)))
902 return (EINVAL);
903
904 msg_type = request->msg_type.type;
905
906 /*
907 * Verify that we have already set up the master sbbc
908 */
909 if (master_mbox == NULL)
910 return (ENXIO);
911 mbox_wait_lock = &master_mbox->mbox_wait_lock[msg_type];
912
913 flags = WAIT_FOR_REPLY|WAIT_FOR_SPACE;
914
915 /*
916 * We want to place a lower limit on the shortest amount of time we
917 * will wait before timing out while communicating with the SC via
918 * the mailbox.
919 */
920 if (wait_time < sbbc_mbox_min_timeout)
921 wait_time = sbbc_mbox_default_timeout;
922
923 stop_time = ddi_get_lbolt() + wait_time * drv_usectohz(MICROSEC);
924
925 /*
926 * If there is a message being processed, sleep until it is our turn.
927 */
928 mutex_enter(&outbox_queue_lock);
929
930 /*
931 * allocate an ID for this message, let it wrap
932 * around transparently.
933 * msg_id == 0 is unsolicited message
934 */
935 msg_id = ++(master_mbox->mbox_msg_id);
936 if (msg_id == 0)
937 msg_id = ++(master_mbox->mbox_msg_id);
938
939 SGSBBC_DBG_MBOX("%s: msg_id = 0x%x, msg_len = 0x%x\n",
940 f, msg_id, request->msg_len);
941
942 /*
943 * A new message can actually grab the lock before the thread
944 * that has just been signaled. Therefore, we need to double
945 * check to make sure that outbox_busy is not already set
946 * after we wake up.
947 *
948 * Potentially this could mean starvation for certain unfortunate
949 * threads that keep getting woken up and putting back to sleep.
950 * But the window of such contention is very small to begin with.
951 */
952 while (outbox_busy) {
953
954 clockleft = cv_timedwait(&outbox_queue, &outbox_queue_lock,
955 stop_time);
956
957 SGSBBC_DBG_MBOX("%s: msg_id = 0x%x is woken up\n", f, msg_id);
958
959 /*
960 * If we have timed out, set status to ETIMEOUT and return.
961 */
962 if (clockleft < 0) {
963 SGSBBC_DBG_MBOX("%s: msg_id = 0x%x has timed out\n",
964 f, msg_id);
965 cmn_err(CE_NOTE,
966 "Timed out obtaining SBBC outbox lock");
967 request->msg_status = ETIMEDOUT;
968 if (response != NULL)
969 response->msg_status = ETIMEDOUT;
970 mutex_exit(&outbox_queue_lock);
971 return (ETIMEDOUT);
972 }
973 }
974
975 outbox_busy = 1;
976 mutex_exit(&outbox_queue_lock);
977
978 /*
979 * We are only locking the OutBox from here, not the whole
980 * mailbox. This is based on the assumption of
981 * complete separation of mailboxes - outbox is
982 * read/write, inbox is read-only.
983 * We only ever update the producer for the
984 * outbox and the consumer for the inbox.
985 */
986 mb_lock = &master_mbox->mbox_out->mb_lock;
987 mutex_enter(mb_lock);
988
989 /*
990 * No response expected ? Just send the message and return
991 */
992 if (response == NULL) {
993 rc = sbbc_mbox_send_msg(request, flags, msg_id, wait_time,
994 stop_time);
995 SGSBBC_DBG_MBOX("%s: msg_id = 0x%x send rc = %d\n",
996 f, msg_id, rc);
997
998 wakeup_next();
999
1000 mutex_exit(mb_lock);
1001 request->msg_status = rc;
1002 return (rc);
1003 }
1004
1005 /*
1006 * allocate/initialise a waiter
1007 */
1008 waiter = kmem_zalloc(sizeof (struct sbbc_msg_waiter), KM_NOSLEEP);
1009
1010 if (waiter == (struct sbbc_msg_waiter *)NULL) {
1011 cmn_err(CE_WARN, "SBBC Mailbox can't allocate waiter\n");
1012
1013 wakeup_next();
1014
1015 mutex_exit(mb_lock);
1016 return (ENOMEM);
1017 }
1018
1019 waiter->w_id = 0; /* Until we get an ID from the send */
1020 waiter->w_msg = response;
1021 waiter->w_msg->msg_status = EINPROGRESS;
1022
1023 cv_init(&waiter->w_cv, NULL, CV_DEFAULT, NULL);
1024
1025 rc = sbbc_mbox_send_msg(request, flags, msg_id, wait_time, stop_time);
1026
1027 wakeup_next();
1028
1029 if (rc != 0) {
1030
1031 request->msg_status = response->msg_status = rc;
1032 mutex_exit(mb_lock);
1033
1034 /* Free the waiter */
1035 cv_destroy(&waiter->w_cv);
1036 kmem_free(waiter, sizeof (struct sbbc_msg_waiter));
1037
1038 SGSBBC_DBG_MBOX("%s: msg_id = 0x%x send rc = %d\n",
1039 f, msg_id, rc);
1040
1041 return (rc);
1042 }
1043
1044 waiter->w_id = msg_id;
1045
1046 /*
1047 * Lock this waiter list and add the waiter
1048 */
1049 mutex_enter(mbox_wait_lock);
1050
1051 if (master_mbox->mbox_wait_list[msg_type] == NULL) {
1052 master_mbox->mbox_wait_list[msg_type] = waiter;
1053 waiter->w_next = NULL;
1054 } else {
1055 struct sbbc_msg_waiter *tmp;
1056 tmp = master_mbox->mbox_wait_list[msg_type];
1057 master_mbox->mbox_wait_list[msg_type] = waiter;
1058 waiter->w_next = tmp;
1059 }
1060
1061 mutex_exit(mb_lock);
1062
1063 /*
1064 * wait here for a response to our message
1065 * holding the mbox_wait_lock for the list ensures
1066 * that the interrupt handler can't get in before
1067 * we block.
1068 * NOTE: We use the request msg_type for the
1069 * the wait_list. This ensures that the
1070 * msg_type won't change.
1071 */
1072 clockleft = cv_timedwait(&waiter->w_cv, mbox_wait_lock, stop_time);
1073
1074 SGSBBC_DBG_MBOX("%s: msg_id = 0x%x is woken up for response\n",
1075 f, msg_id);
1076
1077 /*
1078 * If we have timed out, set msg_status to ETIMEDOUT,
1079 * and remove the waiter from the waiter list.
1080 */
1081 if (clockleft < 0) {
1082 /*
1083 * Remove the waiter from the waiter list.
1084 * If we can't find the waiter in the list,
1085 * 1. msg_status == EINPROGRESS
1086 * It is being processed. We will give it
1087 * a chance to finish.
1088 * 2. msg_status != EINPROGRESS
1089 * It is done processing. We can safely
1090 * remove it.
1091 * If we can find the waiter, it has timed out.
1092 */
1093 SGSBBC_DBG_MBOX("%s: msg_id = 0x%x has timed out\n",
1094 f, msg_id);
1095 if (mbox_find_waiter(msg_type, msg_id) == NULL) {
1096 if (waiter->w_msg->msg_status == EINPROGRESS) {
1097 SGSBBC_DBG_MBOX("%s: Waiting for msg_id = 0x%x "
1098 "complete.\n", f, msg_id);
1099 cv_wait(&waiter->w_cv, mbox_wait_lock);
1100 }
1101 } else {
1102 SGSBBC_DBG_MBOX("%s: setting msg_id = 0x%x "
1103 "to ETIMEDOUT\n", f, msg_id);
1104 cmn_err(CE_NOTE, "Timed out waiting for SC response");
1105 rc = waiter->w_msg->msg_status = ETIMEDOUT;
1106 }
1107 }
1108
1109 /*
1110 * lose the waiter
1111 */
1112 cv_destroy(&waiter->w_cv);
1113 kmem_free(waiter, sizeof (struct sbbc_msg_waiter));
1114
1115 mutex_exit(mbox_wait_lock);
1116
1117 return (rc);
1118
1119 }
1120
1121 static void
wakeup_next()1122 wakeup_next()
1123 {
1124 /*
1125 * Done sending the current message or encounter an error.
1126 * Wake up the one request in the outbox_queue.
1127 */
1128 mutex_enter(&outbox_queue_lock);
1129 outbox_busy = 0;
1130 cv_signal(&outbox_queue);
1131 mutex_exit(&outbox_queue_lock);
1132 }
1133
1134
1135 /* ARGSUSED */
1136 int
sbbc_mbox_send_msg(sbbc_msg_t * msg,int flags,uint_t msg_id,time_t wait_time,clock_t stop_time)1137 sbbc_mbox_send_msg(sbbc_msg_t *msg, int flags, uint_t msg_id,
1138 time_t wait_time, clock_t stop_time)
1139 {
1140 struct sbbc_mbox_header header;
1141 struct sbbc_fragment frag;
1142 int rc = 0;
1143 int bytes_written;
1144 uint32_t intr_enabled;
1145 clock_t clockleft;
1146 static fn_t f = "sbbc_mbox_send_msg";
1147
1148 /*
1149 * First check that the SC has enabled its mailbox
1150 */
1151 rc = iosram_read(SBBC_INTR_SC_ENABLED_KEY, 0,
1152 (caddr_t)&intr_enabled, sizeof (intr_enabled));
1153
1154 if (rc)
1155 return (rc);
1156
1157 if (!(intr_enabled & SBBC_MAILBOX_OUT))
1158 return (ENOTSUP);
1159
1160 /*
1161 * read the mailbox header
1162 */
1163 if (rc = mbox_read_header(SBBC_OUTBOX, &header))
1164 return (rc);
1165
1166 /*
1167 * Allocate/initialise a fragment for this message
1168 */
1169 frag.f_id = msg_id;
1170 frag.f_type = msg->msg_type;
1171 frag.f_status = 0;
1172 frag.f_total_len = msg->msg_len;
1173 frag.f_frag_offset = 0;
1174 /*
1175 * Throw in the message data
1176 */
1177 bcopy(&msg->msg_data, &frag.f_data, sizeof (msg->msg_data));
1178
1179 /*
1180 * If not enough space is available
1181 * write what we can and wait for
1182 * an interrupt to tell us that more
1183 * space is available
1184 */
1185
1186 bytes_written = 0;
1187 do {
1188 rc = mbox_write(&header, &frag, msg);
1189
1190 if (rc != 0 && rc != ENOSPC) {
1191 return (rc);
1192 }
1193
1194 if (rc == 0) {
1195 /*
1196 * Always tell the SC when there is a message.
1197 * Ignore returned value as not being able to
1198 * signal the SC about space available does
1199 * not stop the SC from processing input.
1200 */
1201 (void) iosram_send_intr(SBBC_MAILBOX_OUT);
1202 }
1203
1204 bytes_written += frag.f_frag_len;
1205 frag.f_frag_offset += frag.f_frag_len;
1206 if ((bytes_written < msg->msg_len) || (rc == ENOSPC)) {
1207
1208 if (mbox_has_free_space(&header) <=
1209 sizeof (struct sbbc_fragment)) {
1210
1211 int tmprc;
1212
1213 clockleft = cv_timedwait(
1214 &master_mbox->mbox_out->mb_full,
1215 &master_mbox->mbox_out->mb_lock,
1216 stop_time);
1217
1218 /* Return ETIMEDOUT if we timed out */
1219 if (clockleft < 0) {
1220 SGSBBC_DBG_MBOX("%s: msg_id = 0x%x "
1221 "has timed out\n", f, msg_id);
1222 cmn_err(CE_NOTE,
1223 "Timed out sending message "
1224 "to SC");
1225 return (ETIMEDOUT);
1226 }
1227
1228 /* Read updated header from IOSRAM */
1229 if (tmprc = mbox_read_header(SBBC_OUTBOX,
1230 &header)) {
1231
1232 return (tmprc);
1233 }
1234 }
1235 }
1236
1237 SGSBBC_DBG_MBOX("%s: msg_id = 0x%x, bytes_written = 0x%x, "
1238 "msg_len = 0x%x\n", f,
1239 msg_id, bytes_written, msg->msg_len);
1240 } while ((bytes_written < msg->msg_len) || (rc == ENOSPC));
1241
1242 /*
1243 * this could be a spurious interrupt
1244 * as the SC may be merrily readings its
1245 * mail even as send, but what can you do ? No
1246 * synchronization method between SC <-> OS
1247 * SRAM data eaters means that this is inevitable.
1248 * It would take a bigger brain to fix this.
1249 *
1250 */
1251 (void) iosram_send_intr(SBBC_MAILBOX_OUT);
1252
1253 return (rc);
1254 }
1255
1256
1257 /*
1258 * get next message
1259 * Read the next message from SRAM
1260 * Check if theres an entry on the wait queue
1261 * for this message
1262 * If yes, read the message in and signal
1263 * the waiter (if all the message has been received)
1264 * No, its unsolicited, if theres a handler installed for
1265 * this message type trigger it, otherwise toss
1266 * the message
1267 */
1268 int
sbbc_mbox_recv_msg()1269 sbbc_mbox_recv_msg()
1270 {
1271 struct sbbc_mbox_header header;
1272 struct sbbc_fragment frag;
1273 sbbc_msg_t tmpmsg; /* Temporary msg storage */
1274 int rc = 0, i, first_hdlr, last_hdlr;
1275 uint32_t intr_enabled;
1276 sbbc_intrs_t *intr;
1277 struct sbbc_msg_waiter *waiter;
1278 uint16_t type; /* frag.f_type.type */
1279 uint32_t f_id; /* frag.f_id */
1280 uint32_t f_frag_offset, f_frag_len;
1281 kmutex_t *mbox_wait_lock;
1282 static fn_t f = "sbbc_mbox_recv_msg";
1283
1284 /*
1285 * First check that the OS has enabled its mailbox
1286 */
1287 rc = iosram_read(SBBC_SC_INTR_ENABLED_KEY, 0,
1288 (caddr_t)&intr_enabled, sizeof (intr_enabled));
1289
1290 if (rc) {
1291 return (rc);
1292 }
1293
1294 if (!(intr_enabled & SBBC_MAILBOX_IN))
1295 return (ENOTSUP);
1296
1297 /*
1298 * read the mailbox header
1299 */
1300 if (rc = mbox_read_header(SBBC_INBOX, &header))
1301 return (rc);
1302
1303 /*
1304 * check if any messages available. If
1305 * consumer == producer then no more
1306 * messages
1307 */
1308 if ((header.mailboxes[SBBC_INBOX].mbox_consumer ==
1309 header.mailboxes[SBBC_INBOX].mbox_producer)) {
1310
1311 return (-1);
1312 }
1313
1314 /*
1315 * read the fragment header for this message
1316 */
1317 if (rc = mbox_read_frag(&header, &frag)) {
1318
1319 return (rc);
1320 }
1321
1322 /* Save to local variable for easy reading */
1323 type = frag.f_type.type;
1324 f_id = frag.f_id;
1325
1326 SGSBBC_DBG_MBOX("%s: f_id = 0x%x\n", f, f_id);
1327
1328 /*
1329 * check the message type. If its invalid, we will
1330 * just toss the message
1331 */
1332 if (type >= SBBC_MBOX_MSG_TYPES) {
1333 goto done;
1334 }
1335
1336 /*
1337 * if theres no waiters for this message type, and theres
1338 * no message handler installed, toss it.
1339 *
1340 * Unsolicited messages (f_id == 0) are tricky because we won't know
1341 * when the handler has finished so that we can
1342 * remove the message, so, given the small brains in operation
1343 * here, what we do is restrict junk mail to zero-length
1344 * messages, then we allocate a fragment using kmem,
1345 * make a copy of the fragment in this memory,
1346 * pass this pointer to the fragment, then skip the message.
1347 * So even if there is data associated with the junkmail,
1348 * the message handler doesn't get to see it
1349 * We expect the mesaage handler to free the memory.
1350 */
1351 if (type == SBBC_BROADCAST_MSG) {
1352 /*
1353 * Broadcast message, trigger all handlers
1354 */
1355 first_hdlr = 0;
1356 last_hdlr = SBBC_MBOX_MSG_TYPES - 1;
1357 } else if ((master_mbox->mbox_wait_list[type] == NULL) || (f_id == 0)) {
1358 /*
1359 * Theres no waiters, or its unsolicited anyway
1360 */
1361 first_hdlr = last_hdlr = type;
1362 } else {
1363 /*
1364 * check the fragment message type, look at the wait list for
1365 * that type to find its associated message
1366 *
1367 * First find the message. If we get it, take it off
1368 * the waiter list and read the data. We will
1369 * put it back on the list if necessary.
1370 * This avoids the problem of a second message-in
1371 * interrupt playing with this waiter.
1372 * This will cut down on mutex spinning on the wait
1373 * list locks, also, expect the next fragment to be
1374 * for this messageso we might as well have it at the
1375 * start of the list.
1376 *
1377 * its possible that a return message has a different type,
1378 * (possible but not recommended!). So, if we don't find
1379 * it on the list pointed to by the request type,
1380 * go look at all the other lists
1381 */
1382
1383 mbox_wait_lock = &master_mbox->mbox_wait_lock[type];
1384
1385 mutex_enter(mbox_wait_lock);
1386 if ((waiter = mbox_find_waiter(type, f_id)) == NULL) {
1387 for (i = 0; i < SBBC_MBOX_MSG_TYPES; i++) {
1388 if (i == type)
1389 continue;
1390 if ((waiter = mbox_find_waiter(i, f_id))
1391 != NULL)
1392 break;
1393 }
1394 }
1395 mutex_exit(mbox_wait_lock);
1396
1397 if (waiter == NULL) {
1398 rc = -1;
1399 /*
1400 * there's no waiter for this message, but that
1401 * could mean that this message is the start of
1402 * a send/receive to us, and every 'first' request
1403 * must by definition be unsolicited,
1404 * so trigger the handler
1405 */
1406 first_hdlr = last_hdlr = type;
1407 } else {
1408 SGSBBC_DBG_MBOX("%s: f_id = 0x%x, msg_id = 0x%x, "
1409 "msg_len = 0x%x\n",
1410 f, f_id, waiter->w_id,
1411 waiter->w_msg->msg_len);
1412
1413 rc = mbox_read(&header, &frag, waiter->w_msg);
1414
1415 SGSBBC_DBG_MBOX("%s: f_id = 0x%x, offset = 0x%x, "
1416 "len = 0x%x, total_len = 0x%x\n",
1417 f, frag.f_id, frag.f_frag_offset,
1418 frag.f_frag_len, frag.f_total_len);
1419
1420 if (rc || ((frag.f_frag_offset + frag.f_frag_len) ==
1421 frag.f_total_len)) {
1422 /*
1423 * failed or all the message has been read in
1424 */
1425 mutex_enter(mbox_wait_lock);
1426 waiter->w_msg->msg_status = (rc == ENOMEM)?
1427 rc : frag.f_status;
1428 SGSBBC_DBG_MBOX("%s: msg_status = %d\n",
1429 f, waiter->w_msg->msg_status);
1430 cv_signal(&waiter->w_cv);
1431 mutex_exit(mbox_wait_lock);
1432
1433 } else {
1434 /*
1435 * back on the wait list
1436 */
1437 mutex_enter(mbox_wait_lock);
1438 if (waiter->w_msg->msg_status == ETIMEDOUT) {
1439 cv_signal(&waiter->w_cv);
1440 mutex_exit(mbox_wait_lock);
1441 goto done;
1442 }
1443
1444 if (master_mbox->mbox_wait_list[type] == NULL) {
1445 master_mbox->mbox_wait_list[type] =
1446 waiter;
1447 waiter->w_next = NULL;
1448 } else {
1449 struct sbbc_msg_waiter *tmp;
1450 tmp = master_mbox->mbox_wait_list[type];
1451 master_mbox->mbox_wait_list[type] =
1452 waiter;
1453 waiter->w_next = tmp;
1454 }
1455 mutex_exit(mbox_wait_lock);
1456 }
1457 goto done;
1458 }
1459 }
1460
1461 /*
1462 * Set msg_len to f_frag_len so msg_buf will be large enough
1463 * to contain what is in the fragment.
1464 */
1465 f_frag_len = tmpmsg.msg_len = frag.f_frag_len;
1466 /*
1467 * Save the f_frag_offset for copying into client's space.
1468 * Set frag.f_frag_offset to 0 so we don't have to allocate
1469 * too much space for reading in the message.
1470 */
1471 f_frag_offset = frag.f_frag_offset;
1472 frag.f_frag_offset = 0;
1473
1474 /* Allocate space for msg_buf */
1475 if (f_frag_len != 0 && (tmpmsg.msg_buf =
1476 kmem_alloc(f_frag_len, KM_NOSLEEP)) == NULL) {
1477
1478 rc = ENOMEM;
1479 cmn_err(CE_WARN, "Can't allocate memory"
1480 " for unsolicited messages\n");
1481 } else {
1482 /* Save the incoming message in tmpmsg */
1483 rc = mbox_read(&header, &frag, &tmpmsg);
1484
1485 for (i = first_hdlr; rc == 0 && i <= last_hdlr; i++) {
1486
1487 intr = master_mbox->intrs[i];
1488 if ((intr == NULL) || (intr->sbbc_intr_id == 0)) {
1489 continue;
1490 }
1491
1492 while (intr != NULL) {
1493 /*
1494 * If the client has allocated enough space
1495 * for incoming message, copy into the
1496 * client buffer.
1497 */
1498 sbbc_msg_t *arg = (sbbc_msg_t *)intr->sbbc_arg;
1499 if (arg != (void *)NULL) {
1500 if (arg->msg_len >= frag.f_total_len) {
1501 if (f_frag_len > 0)
1502 bcopy(tmpmsg.msg_buf,
1503 arg->msg_buf +
1504 f_frag_offset,
1505 f_frag_len);
1506 } else {
1507 arg->msg_status = ENOMEM;
1508 }
1509 }
1510
1511 /*
1512 * Only trigger the interrupt when we
1513 * have received the whole message.
1514 */
1515 if (f_frag_offset + f_frag_len ==
1516 frag.f_total_len) {
1517
1518 ddi_trigger_softintr(
1519 intr->sbbc_intr_id);
1520 }
1521 intr = intr->sbbc_intr_next;
1522 }
1523 }
1524
1525 if (f_frag_len != 0) {
1526 /* Don't forget to free the buffer */
1527 kmem_free(tmpmsg.msg_buf, f_frag_len);
1528 }
1529 }
1530 done:
1531 mbox_skip_next_msg(&header);
1532 return (rc);
1533 }
1534
1535 /*
1536 * available free space in the outbox
1537 */
1538 static int
mbox_has_free_space(struct sbbc_mbox_header * header)1539 mbox_has_free_space(struct sbbc_mbox_header *header)
1540 {
1541 uint32_t space = 0;
1542
1543 ASSERT(MUTEX_HELD(&master_mbox->mbox_out->mb_lock));
1544
1545 if (header->mailboxes[SBBC_OUTBOX].mbox_producer ==
1546 header->mailboxes[SBBC_OUTBOX].mbox_consumer) {
1547 /*
1548 * mailbox is empty
1549 */
1550 space += header->mailboxes[SBBC_OUTBOX].mbox_len -
1551 header->mailboxes[SBBC_OUTBOX].mbox_producer;
1552 space +=
1553 header->mailboxes[SBBC_OUTBOX].mbox_producer;
1554 } else if (header->mailboxes[SBBC_OUTBOX].mbox_producer >
1555 header->mailboxes[SBBC_OUTBOX].mbox_consumer) {
1556 space += header->mailboxes[SBBC_OUTBOX].mbox_len -
1557 header->mailboxes[SBBC_OUTBOX].mbox_producer;
1558 space += header->mailboxes[SBBC_OUTBOX].mbox_consumer;
1559 } else {
1560 /*
1561 * mailbox wrapped around
1562 */
1563 space += header->mailboxes[SBBC_OUTBOX].mbox_consumer -
1564 header->mailboxes[SBBC_OUTBOX].mbox_producer;
1565 }
1566
1567 /*
1568 * Need to make sure that the mailbox never
1569 * gets completely full, as consumer == producer is
1570 * our test for empty, so we drop MBOX_ALIGN_BYTES.
1571 */
1572
1573 if (space >= MBOX_ALIGN_BYTES)
1574 space -= MBOX_ALIGN_BYTES;
1575 else
1576 space = 0;
1577
1578 return (space);
1579
1580 }
1581 /*
1582 * Write the data to IOSRAM
1583 * Update the SRAM mailbox header
1584 * Update the local mailbox pointers
1585 * Only write a single fragment. If possible,
1586 * put the whole message into a fragment.
1587 *
1588 * Note: We assume that there is no 'max' message
1589 * size. We will just keep fragmenting.
1590 * Note: We always write to SBBC_OUTBOX and
1591 * read from SBBC_INBOX
1592 *
1593 * If we get an error at any time, return immediately
1594 * without updating the mailbox header in SRAM
1595 */
1596 static int
mbox_write(struct sbbc_mbox_header * header,struct sbbc_fragment * frag,sbbc_msg_t * msg)1597 mbox_write(struct sbbc_mbox_header *header,
1598 struct sbbc_fragment *frag, sbbc_msg_t *msg)
1599 {
1600 int bytes_written, bytes_remaining, free_space;
1601 int rc = 0;
1602 caddr_t src;
1603 uint32_t sram_dst;
1604 int space_at_end, space_at_start;
1605 uint32_t mbox_offset, mbox_len;
1606 uint32_t mbox_producer, mbox_consumer;
1607 uint32_t f_total_len, f_frag_offset;
1608 uint32_t frag_header_size;
1609 static fn_t f = "mbox_write";
1610
1611 ASSERT(MUTEX_HELD(&master_mbox->mbox_out->mb_lock));
1612
1613 /*
1614 * Save to local variables to make code more readable
1615 */
1616 mbox_offset = header->mailboxes[SBBC_OUTBOX].mbox_offset;
1617 mbox_len = header->mailboxes[SBBC_OUTBOX].mbox_len;
1618 mbox_producer = header->mailboxes[SBBC_OUTBOX].mbox_producer;
1619 mbox_consumer = header->mailboxes[SBBC_OUTBOX].mbox_consumer;
1620 f_total_len = frag->f_total_len;
1621 f_frag_offset = frag->f_frag_offset;
1622 frag_header_size = sizeof (struct sbbc_fragment);
1623
1624 SGSBBC_DBG_MBOX("%s: mbox_consumer = 0x%x, "
1625 "mbox_producer = 0x%x\n", f, mbox_consumer, mbox_producer);
1626
1627 /*
1628 * Write pointer in SRAM
1629 */
1630 sram_dst = mbox_offset + mbox_producer;
1631
1632 /*
1633 * NB We assume that the consumer stays constant
1634 * during the write. It may not necessarily
1635 * be the case but it won't cause us any problems, just means
1636 * we fragment more than is absolutely necessary
1637 *
1638 * possible cases
1639 * 1) consumer == producer, mailbox empty
1640 * space_at_end == mailbox end - producer
1641 * space_at_start == producer - MBOX_ALIGN_BYTES
1642 * 2) producer < consumer
1643 * space_at_end = (consumer - producer - MBOX_ALIGN_BYTES)
1644 * space_at_start == 0
1645 * 3) producer > consumer
1646 * space_at_end = mailbox end - producer
1647 * space_at_start = consumer - MBOX_ALIGN_BYTES
1648 *
1649 * (space - MBOX_ALIGN_BYTES) because we need to avoid the
1650 * scenario where the producer wraps around completely and
1651 * producer == consumer, as this is our test for 'empty'.
1652 * Also we want it to be 8-byte aligned.
1653 * Note: start is assumed = 0
1654 */
1655 if (mbox_producer < mbox_consumer) {
1656 space_at_end = mbox_consumer - mbox_producer - MBOX_ALIGN_BYTES;
1657 if (space_at_end < 0)
1658 space_at_end = 0;
1659 space_at_start = 0;
1660 } else {
1661 space_at_end = mbox_len - mbox_producer;
1662 if (mbox_consumer == 0)
1663 space_at_end -= MBOX_ALIGN_BYTES;
1664 space_at_start = mbox_consumer - MBOX_ALIGN_BYTES;
1665 if (space_at_start < 0)
1666 space_at_start = 0;
1667 }
1668
1669 SGSBBC_DBG_MBOX("%s: space_at_end = 0x%x, space_at_start = 0x%x\n",
1670 f, space_at_end, space_at_start);
1671
1672 free_space = space_at_end + space_at_start;
1673
1674 if (free_space < frag_header_size) {
1675 /*
1676 * can't even write a fragment header, so just return
1677 * the caller will block waiting for space
1678 */
1679 frag->f_frag_len = 0;
1680 return (ENOSPC);
1681 }
1682
1683 /*
1684 * How many bytes will be in the fragment ?
1685 */
1686 bytes_remaining = f_total_len - f_frag_offset;
1687 frag->f_frag_len = min(bytes_remaining, free_space - frag_header_size);
1688
1689 SGSBBC_DBG_MBOX("%s: writing header:sram_dst = 0x%x\n",
1690 f, sram_dst);
1691
1692 /*
1693 * we can write the fragment header and some data
1694 * First, the fragment header
1695 */
1696 if (space_at_end >= frag_header_size) {
1697 rc = iosram_write(SBBC_MAILBOX_KEY, sram_dst, (caddr_t)frag,
1698 frag_header_size);
1699 if (rc)
1700 return (rc);
1701
1702 sram_dst = (uint32_t)(sram_dst + frag_header_size);
1703 /*
1704 * Wrap around if we reach the end
1705 */
1706 if (sram_dst >= (mbox_len + mbox_offset)) {
1707 sram_dst = mbox_offset;
1708 }
1709 space_at_end -= frag_header_size;
1710 } else {
1711 /* wraparound */
1712 if (space_at_end) {
1713 rc = iosram_write(SBBC_MAILBOX_KEY, sram_dst,
1714 (caddr_t)frag, space_at_end);
1715 if (rc)
1716 return (rc);
1717 sram_dst = (uint32_t)mbox_offset;
1718 }
1719 rc = iosram_write(SBBC_MAILBOX_KEY, sram_dst,
1720 (caddr_t)((caddr_t)frag + space_at_end),
1721 (frag_header_size - space_at_end));
1722 if (rc)
1723 return (rc);
1724 sram_dst += frag_header_size - space_at_end;
1725 space_at_start -= (frag_header_size - space_at_end);
1726 space_at_end = 0;
1727 }
1728
1729 SGSBBC_DBG_MBOX("%s: space_at_end = 0x%x, space_at_start = 0x%x\n",
1730 f, space_at_end, space_at_start);
1731
1732 /*
1733 * Now the fragment data
1734 */
1735 free_space -= frag_header_size;
1736 src = (caddr_t)(msg->msg_buf + f_frag_offset);
1737 bytes_written = 0;
1738 if (space_at_end) {
1739 SGSBBC_DBG_MBOX("%s: writing data:sram_dst = 0x%x, "
1740 "bytes_remaining = 0x%x\n",
1741 f, sram_dst, bytes_remaining);
1742
1743 if (space_at_end < bytes_remaining)
1744 bytes_written = space_at_end;
1745 else
1746 bytes_written = bytes_remaining;
1747 rc = iosram_write(SBBC_MAILBOX_KEY, sram_dst, src,
1748 bytes_written);
1749 if (rc)
1750 return (rc);
1751
1752 sram_dst = (uint32_t)(sram_dst + bytes_written);
1753 /*
1754 * Wrap around if we reach the end
1755 */
1756 if (sram_dst >= (mbox_len + mbox_offset)) {
1757 sram_dst = mbox_offset;
1758 }
1759 src = (caddr_t)(src + bytes_written);
1760 bytes_remaining -= bytes_written;
1761 }
1762
1763 if ((bytes_remaining > 0) && space_at_start) {
1764 SGSBBC_DBG_MBOX("%s: writing the rest:sram_dst = 0x%x, "
1765 "bytes_remaining = 0x%x\n",
1766 f, sram_dst, bytes_remaining);
1767 if (space_at_start < bytes_remaining) {
1768 rc = iosram_write(SBBC_MAILBOX_KEY, sram_dst, src,
1769 space_at_start);
1770 bytes_written += space_at_start;
1771 } else {
1772 rc = iosram_write(SBBC_MAILBOX_KEY, sram_dst, src,
1773 bytes_remaining);
1774 bytes_written += bytes_remaining;
1775 }
1776 if (rc)
1777 return (rc);
1778 }
1779
1780 frag->f_frag_len = bytes_written;
1781
1782 /*
1783 * update header->mbox_producer (bytes_written + frag_size)
1784 */
1785 sram_dst = mbox_producer + bytes_written + frag_header_size;
1786 if (sram_dst >= mbox_len) {
1787 sram_dst = sram_dst % mbox_len;
1788 }
1789
1790 SGSBBC_DBG_MBOX("%s: after writing data:sram_dst = 0x%x, "
1791 "bytes_written = 0x%x\n", f, sram_dst, bytes_written);
1792
1793 header->mailboxes[SBBC_OUTBOX].mbox_producer = sram_dst;
1794
1795 mbox_update_header(SBBC_OUTBOX, header);
1796
1797
1798 return (rc);
1799 }
1800
1801
1802 /*
1803 * Get the next frag from IOSRAM.
1804 * Write it to the corresponding msg buf.
1805 * The caller must update the SRAM pointers etc.
1806 */
1807 static int
mbox_read(struct sbbc_mbox_header * header,struct sbbc_fragment * frag,sbbc_msg_t * msg)1808 mbox_read(struct sbbc_mbox_header *header,
1809 struct sbbc_fragment *frag, sbbc_msg_t *msg)
1810 {
1811 int rc = 0;
1812 uint32_t sram_src, sram_end;
1813 caddr_t msg_buf;
1814 int bytes_at_start, bytes_at_end;
1815 int bytes_to_read;
1816 uint32_t frag_header_size, frag_total_size;
1817 uint32_t f_frag_offset, f_frag_len;
1818 uint32_t mbox_producer, mbox_consumer;
1819 uint32_t mbox_len, mbox_offset;
1820 static fn_t f = "mbox_read";
1821
1822 ASSERT(MUTEX_HELD(&master_mbox->mbox_in->mb_lock));
1823
1824 /*
1825 * Save to local variables to make code more readable
1826 */
1827 mbox_producer = header->mailboxes[SBBC_INBOX].mbox_producer;
1828 mbox_consumer = header->mailboxes[SBBC_INBOX].mbox_consumer;
1829 mbox_len = header->mailboxes[SBBC_INBOX].mbox_len;
1830 mbox_offset = header->mailboxes[SBBC_INBOX].mbox_offset;
1831 frag_header_size = sizeof (struct sbbc_fragment);
1832 f_frag_offset = frag->f_frag_offset;
1833 f_frag_len = frag->f_frag_len;
1834 frag_total_size = frag_header_size + f_frag_len;
1835
1836 /*
1837 * If the message buffer size is smaller than the fragment
1838 * size, return an error.
1839 */
1840 if (msg->msg_len < f_frag_len) {
1841 rc = ENOMEM;
1842 goto done;
1843 }
1844
1845 msg_buf = (caddr_t)(msg->msg_buf + f_frag_offset);
1846
1847 /*
1848 * Throw in the message data
1849 */
1850 bcopy(&frag->f_data, &msg->msg_data, sizeof (msg->msg_data));
1851
1852 /*
1853 * We have it all, waiter, message, so lets
1854 * go get that puppy!
1855 * Message could be in one or two chunks -
1856 * consumer < producer: 1 chunk, (producer - consumer)
1857 * consumer > producer: 2 chunks, (end - consumer)
1858 * (producer - start)
1859 */
1860 sram_end = (uint32_t)(mbox_offset + mbox_len);
1861 sram_src = (uint32_t)(mbox_offset + mbox_consumer + frag_header_size);
1862
1863 /*
1864 * wraparound
1865 */
1866 if (sram_src >= sram_end)
1867 sram_src -= mbox_len;
1868
1869 /*
1870 * find where the data is
1871 * possible cases
1872 * 1) consumer == producer, mailbox empty
1873 * error
1874 * 2) producer < consumer
1875 * bytes_at_end = mailbox end - consumer
1876 * bytes_at_start = producer
1877 * 3) producer > consumer
1878 * bytes_at_end = producer - consumer
1879 * bytes_at_start = 0
1880 */
1881
1882 SGSBBC_DBG_MBOX("%s: mbox_consumer = 0x%x, mbox_producer = 0x%x, "
1883 "frag_len = 0x%x\n",
1884 f, mbox_consumer, mbox_producer, f_frag_len);
1885
1886 if (mbox_producer == mbox_consumer) {
1887 bytes_at_end = bytes_at_start = 0;
1888 } else if (mbox_producer < mbox_consumer) {
1889 bytes_at_end = mbox_len - mbox_consumer;
1890 bytes_at_start = mbox_producer;
1891 } else {
1892 bytes_at_end = mbox_producer - mbox_consumer;
1893 bytes_at_start = 0;
1894 }
1895
1896 SGSBBC_DBG_MBOX("%s: bytes_at_end = 0x%x, "
1897 "bytes_at_start = 0x%x\n", f, bytes_at_end, bytes_at_start);
1898
1899 if ((bytes_at_end + bytes_at_start) < frag_total_size) {
1900
1901 /*
1902 * mailbox is corrupt
1903 * but what to do ?
1904 */
1905 cmn_err(CE_PANIC, "Corrupt INBOX!\n"
1906 "producer = %x, consumer = %x, bytes_at_start = %x, "
1907 "bytes_at_end = %x\n", mbox_producer, mbox_consumer,
1908 bytes_at_start, bytes_at_end);
1909 }
1910
1911 /*
1912 * If bytes_at_end is greater than header size, read the
1913 * part at the end of the mailbox, and then update the
1914 * pointers and bytes_to_read.
1915 */
1916 if (bytes_at_end > frag_header_size) {
1917 /*
1918 * We are only interested in the data segment.
1919 */
1920 bytes_at_end -= frag_header_size;
1921 bytes_to_read = (bytes_at_end >= f_frag_len)?
1922 f_frag_len : bytes_at_end;
1923 SGSBBC_DBG_MBOX("%s: reading data: sram_src = 0x%x, "
1924 "bytes_to_read = 0x%x\n", f, sram_src, bytes_to_read);
1925 rc = iosram_read(SBBC_MAILBOX_KEY, sram_src, msg_buf,
1926 bytes_to_read);
1927 if (rc) {
1928 goto done;
1929 }
1930
1931 /*
1932 * Update pointers in SRAM and message buffer.
1933 */
1934 sram_src = (uint32_t)mbox_offset;
1935 msg_buf = (caddr_t)(msg_buf + bytes_to_read);
1936 bytes_to_read = f_frag_len - bytes_to_read;
1937 } else {
1938 bytes_to_read = f_frag_len;
1939 }
1940
1941 /*
1942 * wraparound to start of mailbox
1943 */
1944 if (bytes_to_read > 0) {
1945 SGSBBC_DBG_MBOX("%s: reading the rest: sram_src = 0x%x, "
1946 "bytes_to_read = 0x%x\n", f, sram_src, bytes_to_read);
1947 rc = iosram_read(SBBC_MAILBOX_KEY, sram_src, msg_buf,
1948 bytes_to_read);
1949 }
1950
1951 done:
1952 msg->msg_bytes += f_frag_len;
1953
1954 return (rc);
1955 }
1956
1957 /*
1958 * move past the next message in the inbox
1959 */
1960 static void
mbox_skip_next_msg(struct sbbc_mbox_header * header)1961 mbox_skip_next_msg(struct sbbc_mbox_header *header)
1962 {
1963 struct sbbc_fragment frag;
1964 uint32_t next_msg;
1965
1966 ASSERT(MUTEX_HELD(&master_mbox->mbox_in->mb_lock));
1967
1968 if (mbox_read_frag(header, &frag)) {
1969 cmn_err(CE_PANIC, "INBOX is Corrupt !\n");
1970 }
1971
1972 /*
1973 * Move on to the next message
1974 */
1975 next_msg = header->mailboxes[SBBC_INBOX].mbox_consumer;
1976 next_msg += sizeof (struct sbbc_fragment);
1977 next_msg += frag.f_frag_len;
1978 if (next_msg >= header->mailboxes[SBBC_INBOX].mbox_len) {
1979 next_msg = (next_msg +
1980 header->mailboxes[SBBC_INBOX].mbox_len) %
1981 header->mailboxes[SBBC_INBOX].mbox_len;
1982 }
1983 header->mailboxes[SBBC_INBOX].mbox_consumer =
1984 next_msg;
1985
1986 mbox_update_header(SBBC_INBOX, header);
1987
1988 return;
1989
1990 }
1991
1992 static struct sbbc_msg_waiter *
mbox_find_waiter(uint16_t msg_type,uint32_t msg_id)1993 mbox_find_waiter(uint16_t msg_type, uint32_t msg_id)
1994 {
1995 struct sbbc_msg_waiter *waiter, *prev;
1996
1997 prev = NULL;
1998 for (waiter = master_mbox->mbox_wait_list[msg_type];
1999 waiter != NULL; waiter = waiter->w_next) {
2000
2001 if (waiter->w_id == msg_id) {
2002 if (prev != NULL) {
2003 prev->w_next = waiter->w_next;
2004 } else {
2005 master_mbox->mbox_wait_list[msg_type] =
2006 waiter->w_next;
2007 }
2008 break;
2009 }
2010 prev = waiter;
2011 }
2012
2013 return (waiter);
2014 }
2015
2016 static int
mbox_read_header(uint32_t mailbox,struct sbbc_mbox_header * header)2017 mbox_read_header(uint32_t mailbox, struct sbbc_mbox_header *header)
2018 {
2019 struct sbbc_mbox_header *hd;
2020 uint32_t offset;
2021 int rc;
2022
2023 /*
2024 * Initialize a sbbc_mbox_header pointer to 0 so that we
2025 * can use it to calculate the offsets of fields inside
2026 * the structure.
2027 */
2028 hd = (struct sbbc_mbox_header *)0;
2029
2030 if (rc = iosram_read(SBBC_MAILBOX_KEY, 0, (caddr_t)header,
2031 sizeof (struct sbbc_mbox_header)))
2032 return (rc);
2033
2034 /*
2035 * Since the header is read in a byte-by-byte fashion
2036 * using ddi_rep_get8, we need to re-read the producer
2037 * or consumer pointer as integer in case it has changed
2038 * after part of the previous value has been read.
2039 */
2040 switch (mailbox) {
2041
2042 case SBBC_INBOX:
2043 offset = (uint32_t)(uintptr_t)
2044 (&hd->mailboxes[SBBC_INBOX].mbox_producer);
2045 rc = iosram_read(SBBC_MAILBOX_KEY, offset,
2046 (caddr_t)&header->mailboxes[SBBC_INBOX].mbox_producer,
2047 sizeof (uint32_t));
2048 break;
2049 case SBBC_OUTBOX:
2050 offset = (uint32_t)(uintptr_t)
2051 (&hd->mailboxes[SBBC_OUTBOX].mbox_consumer);
2052 rc = iosram_read(SBBC_MAILBOX_KEY, offset,
2053 (caddr_t)&header->mailboxes[SBBC_OUTBOX].mbox_consumer,
2054 sizeof (uint32_t));
2055 break;
2056 default:
2057 cmn_err(CE_PANIC, "Invalid Mbox header type\n");
2058 break;
2059
2060 }
2061
2062 return (rc);
2063 }
2064
2065 /*
2066 * There are only two fields updated by the domain,
2067 * the inbox consumer field and the outbox producer
2068 * field. These fields are protected by the respective
2069 * mbox_{in|out}->mb_lock so that accesses will
2070 * be serialised. The only coherency issue is writing
2071 * back the header, so we do it here after grabbing
2072 * the global mailbox lock.
2073 */
2074 static void
mbox_update_header(uint32_t mailbox,struct sbbc_mbox_header * header)2075 mbox_update_header(uint32_t mailbox, struct sbbc_mbox_header *header)
2076 {
2077 struct sbbc_mbox_header *hd;
2078 uint32_t value, offset, mbox_len;
2079
2080 /*
2081 * Initialize a sbbc_mbox_header pointer to 0 so that we
2082 * can use it to calculate the offsets of fields inside
2083 * the structure.
2084 */
2085 hd = (struct sbbc_mbox_header *)0;
2086
2087 switch (mailbox) {
2088
2089 case SBBC_INBOX:
2090 value = header->mailboxes[SBBC_INBOX].mbox_consumer;
2091 offset = (uint32_t)(uintptr_t)
2092 (&hd->mailboxes[SBBC_INBOX].mbox_consumer);
2093
2094 mbox_len = header->mailboxes[SBBC_INBOX].mbox_len;
2095 break;
2096 case SBBC_OUTBOX:
2097 value = header->mailboxes[SBBC_OUTBOX].mbox_producer;
2098 offset = (uint32_t)(uintptr_t)
2099 (&hd->mailboxes[SBBC_OUTBOX].mbox_producer);
2100 mbox_len = header->mailboxes[SBBC_OUTBOX].mbox_len;
2101 break;
2102 default:
2103 cmn_err(CE_PANIC, "Invalid Mbox header type\n");
2104 break;
2105
2106 }
2107
2108 /*
2109 * If the last read/write would cause the next read/write
2110 * to be unaligned, we skip on modulo MBOX_ALIGN_BYTES.
2111 * This is OK because all the mailbox handlers will
2112 * conform to this.
2113 */
2114 if (value % MBOX_ALIGN_BYTES) {
2115 value += (MBOX_ALIGN_BYTES - (value % MBOX_ALIGN_BYTES));
2116 value %= mbox_len;
2117 }
2118
2119 if (iosram_write(SBBC_MAILBOX_KEY, offset, (caddr_t)&value,
2120 sizeof (uint32_t))) {
2121 cmn_err(CE_PANIC, "Mailbox Corrupt ! \n");
2122 }
2123
2124 /*
2125 * Update internal pointers so they won't be out of sync with
2126 * the values in IOSRAM.
2127 */
2128 switch (mailbox) {
2129
2130 case SBBC_INBOX:
2131 header->mailboxes[SBBC_INBOX].mbox_consumer = value;
2132 break;
2133 case SBBC_OUTBOX:
2134 header->mailboxes[SBBC_OUTBOX].mbox_producer = value;
2135 break;
2136 }
2137 }
2138
2139 static int
mbox_read_frag(struct sbbc_mbox_header * header,struct sbbc_fragment * frag)2140 mbox_read_frag(struct sbbc_mbox_header *header,
2141 struct sbbc_fragment *frag)
2142 {
2143 int rc = 0;
2144 uint32_t sram_src, bytes;
2145 caddr_t dst;
2146
2147 ASSERT(MUTEX_HELD(&master_mbox->mbox_in->mb_lock));
2148 /*
2149 * read the fragment header for this message
2150 */
2151 sram_src = (uint32_t)(header->mailboxes[SBBC_INBOX].mbox_offset +
2152 header->mailboxes[SBBC_INBOX].mbox_consumer);
2153
2154 /*
2155 * wraparound ?
2156 */
2157 if ((header->mailboxes[SBBC_INBOX].mbox_consumer +
2158 sizeof (struct sbbc_fragment)) >=
2159 header->mailboxes[SBBC_INBOX].mbox_len) {
2160
2161 dst = (caddr_t)frag;
2162 bytes = header->mailboxes[SBBC_INBOX].mbox_len -
2163 header->mailboxes[SBBC_INBOX].mbox_consumer;
2164
2165 if (rc = iosram_read(SBBC_MAILBOX_KEY, sram_src, dst, bytes)) {
2166 return (rc);
2167 }
2168
2169 dst += bytes;
2170 sram_src = header->mailboxes[SBBC_INBOX].mbox_offset;
2171 bytes = (header->mailboxes[SBBC_INBOX].mbox_consumer +
2172 sizeof (struct sbbc_fragment)) %
2173 header->mailboxes[SBBC_INBOX].mbox_len;
2174
2175 if (rc = iosram_read(SBBC_MAILBOX_KEY, sram_src,
2176 dst, bytes)) {
2177 return (rc);
2178 }
2179 } else {
2180 if (rc = iosram_read(SBBC_MAILBOX_KEY, sram_src, (caddr_t)frag,
2181 sizeof (struct sbbc_fragment))) {
2182 return (rc);
2183 }
2184 }
2185
2186 return (0);
2187 }
2188
2189
2190 /*
2191 * This function is triggered by a soft interrupt and it's purpose is to call
2192 * to kadmin() to shutdown the Domain.
2193 */
2194 /*ARGSUSED0*/
2195 static uint_t
sbbc_do_fast_shutdown(char * arg)2196 sbbc_do_fast_shutdown(char *arg)
2197 {
2198 (void) kadmin(A_SHUTDOWN, AD_POWEROFF, NULL, kcred);
2199
2200 /*
2201 * If kadmin fails for some reason then we bring the system down
2202 * via power_down(), or failing that using halt().
2203 */
2204 power_down("kadmin() failed, trying power_down()");
2205
2206 halt("power_down() failed, trying halt()");
2207
2208 /*
2209 * We should never make it this far, so something must have gone
2210 * horribly, horribly wrong.
2211 */
2212 /*NOTREACHED*/
2213 return (DDI_INTR_UNCLAIMED);
2214 }
2215
2216
2217 /*
2218 * This function handles unsolicited PANIC_SHUTDOWN events
2219 */
2220 static uint_t
sbbc_panic_shutdown_handler(char * arg)2221 sbbc_panic_shutdown_handler(char *arg)
2222 {
2223 static fn_t f = "sbbc_panic_shutdown_handler()";
2224
2225 sg_panic_shutdown_t *payload = NULL;
2226 sbbc_msg_t *msg = NULL;
2227
2228 if (arg == NULL) {
2229 SGSBBC_DBG_EVENT(CE_NOTE, "%s: arg == NULL", f);
2230 return (DDI_INTR_UNCLAIMED);
2231 }
2232
2233 msg = (sbbc_msg_t *)arg;
2234
2235 if (msg->msg_buf == NULL) {
2236 SGSBBC_DBG_EVENT(CE_NOTE, "%s: msg_buf == NULL", f);
2237 return (DDI_INTR_UNCLAIMED);
2238 }
2239
2240 payload = (sg_panic_shutdown_t *)msg->msg_buf;
2241
2242 switch (*payload) {
2243 case SC_EVENT_PANIC_ENV:
2244
2245 /*
2246 * Let the user know why the domain is going down.
2247 */
2248 cmn_err(CE_WARN, "%s", PANIC_ENV_EVENT_MSG);
2249
2250 /*
2251 * trigger sbbc_do_fast_shutdown().
2252 */
2253 ddi_trigger_softintr(panic_softintr_id);
2254
2255 /*NOTREACHED*/
2256 break;
2257
2258 case SC_EVENT_PANIC_KEYSWITCH:
2259 /*
2260 * The SC warns a user if they try a destructive keyswitch
2261 * command on a Domain which is currently running Solaris.
2262 * If the user chooses to continue despite our best advise
2263 * then we bring down the Domain immediately without trying
2264 * to shut the system down gracefully.
2265 */
2266 break;
2267
2268 default:
2269 SGSBBC_DBG_EVENT(CE_NOTE, "%s: Unknown payload:%d", f,
2270 *payload);
2271 return (DDI_INTR_UNCLAIMED);
2272 }
2273
2274 return (DDI_INTR_CLAIMED);
2275 }
2276
2277 /*
2278 * dp_get_cores()
2279 *
2280 * Checks cpu implementation for the input cpuid and returns
2281 * the number of cores.
2282 * If implementation cannot be determined, returns 1
2283 */
2284 static int
dp_get_cores(uint16_t cpuid)2285 dp_get_cores(uint16_t cpuid)
2286 {
2287 int bd, ii, impl, nc;
2288
2289 bd = cpuid / 4;
2290 nc = SG_MAX_CPUS_PER_BD;
2291
2292 /* find first with valid implementation */
2293 for (ii = 0; ii < nc; ii++)
2294 if (cpu[MAKE_CPUID(bd, ii)]) {
2295 impl = cpunodes[MAKE_CPUID(bd, ii)].implementation;
2296 break;
2297 }
2298
2299 if (IS_JAGUAR(impl) || IS_PANTHER(impl))
2300 return (2);
2301 else
2302 return (1);
2303 }
2304
2305 /*
2306 * dp_payload_add_cpus()
2307 *
2308 * From datapath mailbox message, determines the number of and safari IDs
2309 * for affected cpus, then adds this info to the datapath ereport.
2310 *
2311 */
2312 static int
dp_payload_add_cpus(plat_datapath_info_t * dpmsg,nvlist_t * erp)2313 dp_payload_add_cpus(plat_datapath_info_t *dpmsg, nvlist_t *erp)
2314 {
2315 int jj = 0, numcpus = 0;
2316 int bd, procpos, ii, num, ncores, ret;
2317 uint16_t *dparray, cpuid;
2318 uint64_t *snarray;
2319
2320 /* check for multiple core architectures */
2321 ncores = dp_get_cores(dpmsg->cpuid);
2322
2323 switch (dpmsg->type) {
2324 case DP_CDS_TYPE:
2325 numcpus = ncores;
2326 break;
2327
2328 case DP_DX_TYPE:
2329 numcpus = 2 * ncores;
2330 break;
2331
2332 case DP_RP_TYPE:
2333 numcpus = SG_MAX_CPUS_PER_BD;
2334 break;
2335
2336 default:
2337 ASSERT(0);
2338 return (-1);
2339 }
2340
2341 num = numcpus;
2342
2343 /*
2344 * populate dparray with impacted cores (only those present)
2345 */
2346 dparray = kmem_zalloc(num * sizeof (uint16_t *), KM_SLEEP);
2347 bd = SG_PORTID_TO_BOARD_NUM(SG_CPUID_TO_PORTID(dpmsg->cpuid));
2348 procpos = SG_CPUID_TO_PORTID(dpmsg->cpuid) & 0x3;
2349
2350 mutex_enter(&cpu_lock);
2351
2352 switch (dpmsg->type) {
2353
2354 case DP_CDS_TYPE:
2355 /*
2356 * For a CDS error, it's the reporting cpuid
2357 * and it's other core (if present)
2358 */
2359 cpuid = dpmsg->cpuid & 0x1FF; /* core 0 */
2360 if (cpu[cpuid])
2361 dparray[jj++] = cpuid;
2362
2363 cpuid = dpmsg->cpuid | SG_CORE_ID_MASK; /* core 1 */
2364 if (cpu[cpuid])
2365 dparray[jj++] = cpuid;
2366 break;
2367
2368 case DP_DX_TYPE:
2369 /*
2370 * For a DX error, it's the reporting cpuid (all
2371 * cores) and the other CPU sharing the same
2372 * DX<-->DCDS interface (all cores)
2373 */
2374
2375 /* reporting cpuid */
2376 cpuid = dpmsg->cpuid & 0x1FF; /* core 0 */
2377 if (cpu[cpuid])
2378 dparray[jj++] = cpuid;
2379
2380 cpuid = dpmsg->cpuid | SG_CORE_ID_MASK; /* core 1 */
2381 if (cpu[cpuid])
2382 dparray[jj++] = cpuid;
2383
2384 /* find partner cpuid */
2385 if (procpos == 0 || procpos == 2)
2386 cpuid = dpmsg->cpuid + 1;
2387 else
2388 cpuid = dpmsg->cpuid - 1;
2389
2390 /* add partner cpuid */
2391 cpuid &= 0x1FF; /* core 0 */
2392 if (cpu[cpuid])
2393 dparray[jj++] = cpuid;
2394
2395 cpuid |= SG_CORE_ID_MASK; /* core 1 */
2396 if (cpu[cpuid])
2397 dparray[jj++] = cpuid;
2398 break;
2399
2400 case DP_RP_TYPE:
2401 /*
2402 * For a RP error, it's all cpuids (all cores) on
2403 * the reporting board
2404 */
2405 for (ii = 0; ii < SG_MAX_CMPS_PER_BD; ii++) {
2406 cpuid = MAKE_CPUID(bd, ii);
2407 if (cpu[cpuid]) /* core 0 */
2408 dparray[jj++] = cpuid;
2409 cpuid |= SG_CORE_ID_MASK;
2410 if (cpu[cpuid]) /* core 1 */
2411 dparray[jj++] = cpuid;
2412 }
2413 break;
2414 }
2415
2416 mutex_exit(&cpu_lock);
2417
2418 /*
2419 * The datapath message could not be associated with any
2420 * configured CPU.
2421 */
2422 if (!jj) {
2423 kmem_free(dparray, num * sizeof (uint16_t *));
2424 ret = nvlist_add_uint32(erp, DP_LIST_SIZE, jj);
2425 ASSERT(ret == 0);
2426 return (-1);
2427 }
2428
2429 snarray = kmem_zalloc(jj * sizeof (uint64_t), KM_SLEEP);
2430 for (ii = 0; ii < jj; ii++)
2431 snarray[ii] = cpunodes[dparray[ii]].device_id;
2432
2433 ret = nvlist_add_uint32(erp, DP_LIST_SIZE, jj);
2434 ret |= nvlist_add_uint16_array(erp, DP_LIST, dparray, jj);
2435 ret |= nvlist_add_uint64_array(erp, SN_LIST, snarray, jj);
2436 ASSERT(ret == 0);
2437
2438 kmem_free(dparray, num * sizeof (uint16_t *));
2439 kmem_free(snarray, jj * sizeof (uint64_t *));
2440
2441 return (0);
2442 }
2443
2444 /*
2445 * sbbc_dp_trans_event() - datapath message handler.
2446 *
2447 * Process datapath error and fault messages received from the SC. Checks
2448 * for, and disregards, messages associated with I/O boards. Otherwise,
2449 * extracts message info to produce a datapath ereport.
2450 */
2451 /*ARGSUSED*/
2452 static uint_t
sbbc_dp_trans_event(char * arg)2453 sbbc_dp_trans_event(char *arg)
2454 {
2455 const char *f = "sbbc_dp_trans_event()";
2456 nvlist_t *erp, *detector, *hcelem;
2457 char buf[FM_MAX_CLASS];
2458 int board;
2459 plat_datapath_info_t *dpmsg;
2460 sbbc_msg_t *msg;
2461 int msgtype;
2462
2463 /* set i/f message and payload pointers */
2464 msg = &dp_payload_msg;
2465 dpmsg = &dp_payload;
2466 msgtype = msg->msg_type.type;
2467
2468 cmn_err(CE_NOTE, "%s: msgtype=0x%x\n", f, msgtype);
2469 cmn_err(CE_NOTE, "type=0x%x cpuid=0x%x t_value=0x%x\n", dpmsg->type,
2470 dpmsg->cpuid, dpmsg->t_value);
2471
2472 /* check for valid type */
2473 if (dpmsg->type > DP_RP_TYPE) {
2474 cmn_err(CE_WARN, "%s: dpmsg type 0x%x invalid\n",
2475 f, dpmsg->type);
2476 return (DDI_INTR_CLAIMED);
2477 }
2478
2479 /* check for I/O board message - Schizo AIDs are 25 - 30 */
2480 if (dpmsg->cpuid > 23) {
2481 cmn_err(CE_NOTE, "%s: ignore I/O board msg\n", f);
2482 return (DDI_INTR_CLAIMED);
2483 }
2484
2485 /* allocate space for ereport */
2486 erp = fm_nvlist_create(NULL);
2487
2488 /*
2489 * Member Name Data Type Comments
2490 * ----------- --------- -----------
2491 * version uint8 0
2492 * class string "asic"
2493 * ENA uint64 ENA Format 1
2494 * detector fmri aggregated ID data for SC-DE
2495 *
2496 * Datapath ereport subclasses and data payloads:
2497 * There will be two types of ereports (error and fault) which will be
2498 * identified by the "type" member.
2499 *
2500 * ereport.asic.serengeti.cds.cds-dp
2501 * ereport.asic.serengeti.dx.dx-dp (board)
2502 * ereport.asic.serengeti.rp.rp-dp (centerplane)
2503 *
2504 * Member Name Data Type Comments
2505 * ----------- --------- -----------
2506 * erptype uint16 derived from message type: error or
2507 * fault
2508 * t-value uint32 SC's datapath SERD timeout threshold
2509 * dp-list-sz uint8 number of dp-list array elements
2510 * dp-list array of uint16 Safari IDs of affected cpus
2511 * sn-list array of uint64 Serial numbers of affected cpus
2512 */
2513
2514 /* compose common ereport elements */
2515 detector = fm_nvlist_create(NULL);
2516
2517 /*
2518 * Create legacy FMRI for the detector
2519 */
2520 board = SG_PORTID_TO_BOARD_NUM(SG_CPUID_TO_PORTID(dpmsg->cpuid));
2521 switch (dpmsg->type) {
2522 case DP_CDS_TYPE:
2523 case DP_DX_TYPE:
2524 (void) snprintf(buf, FM_MAX_CLASS, "SB%d", board);
2525 break;
2526 case DP_RP_TYPE:
2527 (void) snprintf(buf, FM_MAX_CLASS, "RP");
2528 break;
2529 default:
2530 (void) snprintf(buf, FM_MAX_CLASS, "UNKNOWN");
2531 break;
2532 }
2533
2534 hcelem = fm_nvlist_create(NULL);
2535
2536 (void) nvlist_add_string(hcelem, FM_FMRI_HC_NAME, FM_FMRI_LEGACY_HC);
2537 (void) nvlist_add_string(hcelem, FM_FMRI_HC_ID, buf);
2538
2539 (void) nvlist_add_uint8(detector, FM_VERSION, FM_HC_SCHEME_VERSION);
2540 (void) nvlist_add_string(detector, FM_FMRI_SCHEME, FM_FMRI_SCHEME_HC);
2541 (void) nvlist_add_string(detector, FM_FMRI_HC_ROOT, "");
2542 (void) nvlist_add_uint32(detector, FM_FMRI_HC_LIST_SZ, 1);
2543 (void) nvlist_add_nvlist_array(detector, FM_FMRI_HC_LIST, &hcelem, 1);
2544
2545 /* build ereport class name */
2546 (void) snprintf(buf, FM_MAX_CLASS, "asic.serengeti.%s.%s-%s",
2547 dperrtype[dpmsg->type], dperrtype[dpmsg->type],
2548 FM_ERROR_DATAPATH);
2549
2550 fm_ereport_set(erp, FM_EREPORT_VERSION, buf,
2551 fm_ena_generate(0, FM_ENA_FMT1), detector, NULL);
2552
2553 /* add payload elements */
2554 if (msgtype == MBOX_EVENT_DP_ERROR)
2555 fm_payload_set(erp,
2556 DP_EREPORT_TYPE, DATA_TYPE_UINT16, DP_ERROR, NULL);
2557 else
2558 fm_payload_set(erp,
2559 DP_EREPORT_TYPE, DATA_TYPE_UINT16, DP_FAULT, NULL);
2560
2561 fm_payload_set(erp, DP_TVALUE, DATA_TYPE_UINT32, dpmsg->t_value, NULL);
2562
2563 (void) dp_payload_add_cpus(dpmsg, erp);
2564
2565 /* post ereport */
2566 fm_ereport_post(erp, EVCH_SLEEP);
2567
2568 /* free ereport memory */
2569 fm_nvlist_destroy(erp, FM_NVA_FREE);
2570 fm_nvlist_destroy(detector, FM_NVA_FREE);
2571
2572 return (DDI_INTR_CLAIMED);
2573 }
2574
2575 static uint_t
sbbc_datapath_error_msg_handler(char * arg)2576 sbbc_datapath_error_msg_handler(char *arg)
2577 {
2578 static fn_t f = "sbbc_datapath_error_msg_handler()";
2579 sbbc_msg_t *msg = NULL;
2580
2581 if (arg == NULL) {
2582 SGSBBC_DBG_EVENT(CE_NOTE, "%s: arg == NULL", f);
2583 return (DDI_INTR_UNCLAIMED);
2584 }
2585
2586 msg = (sbbc_msg_t *)arg;
2587
2588 if (msg->msg_buf == NULL) {
2589 SGSBBC_DBG_EVENT(CE_NOTE, "%s: msg_buf == NULL", f);
2590 return (DDI_INTR_UNCLAIMED);
2591 }
2592
2593 msg->msg_type.type = MBOX_EVENT_DP_ERROR;
2594
2595 /* trigger sbbc_dp_trans_event() */
2596 ddi_trigger_softintr(dp_softintr_id);
2597
2598 return (DDI_INTR_CLAIMED);
2599 }
2600
2601 static uint_t
sbbc_datapath_fault_msg_handler(char * arg)2602 sbbc_datapath_fault_msg_handler(char *arg)
2603 {
2604
2605 static fn_t f = "sbbc_datapath_fault_msg_handler()";
2606
2607 sbbc_msg_t *msg = NULL;
2608
2609 if (arg == NULL) {
2610 SGSBBC_DBG_EVENT(CE_NOTE, "%s: arg == NULL", f);
2611 return (DDI_INTR_UNCLAIMED);
2612 }
2613
2614 msg = (sbbc_msg_t *)arg;
2615
2616 if (msg->msg_buf == NULL) {
2617 SGSBBC_DBG_EVENT(CE_NOTE, "%s: msg_buf == NULL", f);
2618 return (DDI_INTR_UNCLAIMED);
2619 }
2620
2621 msg->msg_type.type = MBOX_EVENT_DP_FAULT;
2622
2623 /* trigger sbbc_dp_trans_event() */
2624 ddi_trigger_softintr(dp_softintr_id);
2625
2626 return (DDI_INTR_CLAIMED);
2627 }
2628
2629 /*
2630 * Log an ECC event message to the SC. This is called from the
2631 * sbbc_ecc_mbox_taskq or directly from plat_send_ecc_mailbox_msg
2632 * for indictment messages.
2633 */
2634 int
sbbc_mbox_ecc_output(sbbc_ecc_mbox_t * msgp)2635 sbbc_mbox_ecc_output(sbbc_ecc_mbox_t *msgp)
2636 {
2637 int rv;
2638 plat_capability_data_t *cap;
2639 plat_dimm_sid_board_data_t *ddata;
2640 plat_ecc_msg_hdr_t *hdr;
2641
2642 rv = sbbc_mbox_request_response(&msgp->ecc_req, &msgp->ecc_resp,
2643 sbbc_mbox_default_timeout);
2644
2645 if (rv != 0) {
2646 /*
2647 * Indictment messages use the return value to indicate a
2648 * problem in the mailbox. For Error mailbox messages, we'll
2649 * have to use a syslog message.
2650 */
2651 if (msgp->ecc_log_error) {
2652 if (sbbc_ecc_mbox_send_errs == 0) {
2653 cmn_err(CE_NOTE, "!Solaris failed to send a "
2654 "message (0x%x/0x%x) to the System "
2655 "Controller. Error: %d, Message Status: %d",
2656 msgp->ecc_resp.msg_type.type,
2657 msgp->ecc_resp.msg_type.sub_type,
2658 rv, msgp->ecc_resp.msg_status);
2659 }
2660
2661 if (++sbbc_ecc_mbox_send_errs >=
2662 sbbc_ecc_mbox_err_throttle) {
2663 sbbc_ecc_mbox_send_errs = 0;
2664 }
2665 }
2666
2667 } else if (msgp->ecc_resp.msg_status != 0) {
2668 if (msgp->ecc_resp.msg_type.type == INFO_MBOX) {
2669 switch (msgp->ecc_resp.msg_type.sub_type) {
2670 case INFO_MBOX_ECC:
2671 hdr = (plat_ecc_msg_hdr_t *)
2672 msgp->ecc_req.msg_buf;
2673 if (hdr->emh_msg_type ==
2674 PLAT_ECC_DIMM_SID_MESSAGE) {
2675 rv = msgp->ecc_resp.msg_status;
2676 break;
2677 }
2678 /*FALLTHROUGH*/
2679 case INFO_MBOX_ECC_CAP:
2680 /*
2681 * The positive response comes only
2682 * from the AVL FS1 updated SC.
2683 * If the firmware is either downgraded
2684 * or failover to an older version, then
2685 * lets reset the SC capability to
2686 * default.
2687 */
2688 plat_ecc_capability_sc_set
2689 (PLAT_ECC_CAPABILITY_SC_DEFAULT);
2690 break;
2691 default:
2692 break;
2693 }
2694 }
2695 if (msgp->ecc_log_error) {
2696 if (sbbc_ecc_mbox_inval_errs == 0) {
2697 cmn_err(CE_NOTE, "!An internal error (%d) "
2698 "occurred in the System Controller while "
2699 "processing this message (0x%x/0x%x)",
2700 msgp->ecc_resp.msg_status,
2701 msgp->ecc_resp.msg_type.type,
2702 msgp->ecc_resp.msg_type.sub_type);
2703 }
2704 if (msgp->ecc_resp.msg_status == EINVAL) {
2705 if (++sbbc_ecc_mbox_inval_errs >=
2706 sbbc_ecc_mbox_err_throttle) {
2707 sbbc_ecc_mbox_inval_errs = 0;
2708 }
2709 rv = ENOMSG;
2710 } else {
2711 if (++sbbc_ecc_mbox_other_errs >=
2712 sbbc_ecc_mbox_err_throttle) {
2713 sbbc_ecc_mbox_other_errs = 0;
2714 }
2715 rv = msgp->ecc_resp.msg_status;
2716 }
2717 }
2718
2719 } else {
2720 if (msgp->ecc_resp.msg_type.type == INFO_MBOX) {
2721 switch (msgp->ecc_resp.msg_type.sub_type) {
2722 case INFO_MBOX_ECC_CAP:
2723 /*
2724 * Successfully received the response
2725 * for the capability message, so updating
2726 * the SC ECC messaging capability.
2727 */
2728 cap = (plat_capability_data_t *)
2729 msgp->ecc_resp.msg_buf;
2730 plat_ecc_capability_sc_set
2731 (cap->capd_capability);
2732 break;
2733
2734 case INFO_MBOX_ECC:
2735 hdr = (plat_ecc_msg_hdr_t *)
2736 msgp->ecc_resp.msg_buf;
2737 if (hdr && (hdr->emh_msg_type ==
2738 PLAT_ECC_DIMM_SID_MESSAGE)) {
2739 /*
2740 * Successfully received a response
2741 * to a request for DIMM serial ids.
2742 */
2743 ddata = (plat_dimm_sid_board_data_t *)
2744 msgp->ecc_resp.msg_buf;
2745 (void) plat_store_mem_sids(ddata);
2746 }
2747 break;
2748
2749 default:
2750 break;
2751 }
2752 }
2753 }
2754
2755 if (msgp->ecc_resp.msg_buf)
2756 kmem_free((void *)msgp->ecc_resp.msg_buf,
2757 (size_t)msgp->ecc_resp.msg_len);
2758
2759 kmem_free((void *)msgp->ecc_req.msg_buf, (size_t)msgp->ecc_req.msg_len);
2760 kmem_free(msgp, sizeof (sbbc_ecc_mbox_t));
2761 return (rv);
2762 }
2763
2764 /*
2765 * Enqueue ECC event message on taskq to SC. This is invoked from
2766 * plat_send_ecc_mailbox_msg() for each ECC event generating a message.
2767 */
2768 void
sbbc_mbox_queue_ecc_event(sbbc_ecc_mbox_t * sbbc_ecc_msgp)2769 sbbc_mbox_queue_ecc_event(sbbc_ecc_mbox_t *sbbc_ecc_msgp)
2770 {
2771 /*
2772 * Create the ECC event mailbox taskq, if it does not yet exist.
2773 * This must be done here rather than in sbbc_mbox_init(). The
2774 * sgsbbc driver is loaded very early in the boot flow. Calling
2775 * taskq_create() from sbbc_mbox_init could lead to a boot deadlock.
2776 *
2777 * There might be a tiny probability that two ECC handlers on
2778 * different processors could arrive here simultaneously. If
2779 * the taskq has not been created previously, then these two
2780 * simultaneous events could cause the creation of an extra taskq.
2781 * Given the extremely small likelihood (if not outright impossibility)
2782 * of this occurrence, sbbc_ecc_mbox_taskq is not protected by a lock.
2783 */
2784
2785 if (sbbc_ecc_mbox_taskq == NULL) {
2786 sbbc_ecc_mbox_taskq = taskq_create("ECC_event_mailbox", 1,
2787 minclsyspri, ECC_MBOX_TASKQ_MIN, ECC_MBOX_TASKQ_MAX,
2788 TASKQ_PREPOPULATE);
2789 if (sbbc_ecc_mbox_taskq == NULL) {
2790 if (sbbc_ecc_mbox_taskq_errs == 0) {
2791 cmn_err(CE_NOTE, "Unable to create mailbox "
2792 "task queue for ECC event logging to "
2793 "System Controller");
2794 }
2795 if (++sbbc_ecc_mbox_taskq_errs >=
2796 sbbc_ecc_mbox_err_throttle) {
2797 sbbc_ecc_mbox_taskq_errs = 0;
2798 }
2799
2800 kmem_free((void *)sbbc_ecc_msgp->ecc_req.msg_buf,
2801 (size_t)sbbc_ecc_msgp->ecc_req.msg_len);
2802 kmem_free((void *)sbbc_ecc_msgp,
2803 sizeof (sbbc_ecc_mbox_t));
2804 return;
2805 }
2806
2807 /*
2808 * Reset error counter so that first taskq_dispatch
2809 * error will be output
2810 */
2811 sbbc_ecc_mbox_taskq_errs = 0;
2812 }
2813
2814 /*
2815 * Enqueue the message
2816 */
2817
2818 if (taskq_dispatch(sbbc_ecc_mbox_taskq,
2819 (task_func_t *)sbbc_mbox_ecc_output, sbbc_ecc_msgp,
2820 TQ_NOSLEEP) == TASKQID_INVALID) {
2821
2822 if (sbbc_ecc_mbox_taskq_errs == 0) {
2823 cmn_err(CE_NOTE, "Unable to send ECC event "
2824 "message to System Controller");
2825 }
2826 if (++sbbc_ecc_mbox_taskq_errs >= sbbc_ecc_mbox_err_throttle) {
2827 sbbc_ecc_mbox_taskq_errs = 0;
2828 }
2829
2830 kmem_free((void *)sbbc_ecc_msgp->ecc_req.msg_buf,
2831 (size_t)sbbc_ecc_msgp->ecc_req.msg_len);
2832 kmem_free((void *)sbbc_ecc_msgp, sizeof (sbbc_ecc_mbox_t));
2833 }
2834 }
2835
2836 static uint_t
cap_ecc_msg_handler(char * addr)2837 cap_ecc_msg_handler(char *addr)
2838 {
2839 sbbc_msg_t *msg = NULL;
2840 plat_capability_data_t *cap = NULL;
2841 static fn_t f = "cap_ecc_msg_handler";
2842
2843 msg = (sbbc_msg_t *)addr;
2844
2845 if (msg == NULL) {
2846 SGSBBC_DBG_EVENT(CE_WARN, "cap_ecc_msg_handler() called with "
2847 "null addr");
2848 return (DDI_INTR_CLAIMED);
2849 }
2850
2851 if (msg->msg_buf == NULL) {
2852 SGSBBC_DBG_EVENT(CE_WARN, "cap_ecc_msg_handler() called with "
2853 "null data buffer");
2854 return (DDI_INTR_CLAIMED);
2855 }
2856
2857 cap = (plat_capability_data_t *)msg->msg_buf;
2858 switch (cap->capd_msg_type) {
2859 case PLAT_ECC_CAPABILITY_MESSAGE:
2860 SGSBBC_DBG_MBOX("%s: capability 0x%x\n", f,
2861 cap->capd_capability);
2862 plat_ecc_capability_sc_set(cap->capd_capability);
2863 break;
2864 default:
2865 SGSBBC_DBG_MBOX("%s: Unknown message type = 0x%x\n", f,
2866 cap->capd_msg_type);
2867 break;
2868 }
2869
2870 return (DDI_INTR_CLAIMED);
2871 }
2872