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 (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 /*
27 * hermon_cmd.c
28 * Hermon Firmware Command Routines
29 *
30 * Implements all the routines necessary for allocating, posting, and
31 * freeing commands for the Hermon firmware. These routines manage a
32 * preallocated list of command mailboxes and provide interfaces to post
33 * each of the several dozen commands to the Hermon firmware.
34 */
35
36 #include <sys/types.h>
37 #include <sys/conf.h>
38 #include <sys/ddi.h>
39 #include <sys/sunddi.h>
40 #include <sys/modctl.h>
41 #include <sys/bitmap.h>
42
43 #include <sys/ib/adapters/hermon/hermon.h>
44
45 static int hermon_impl_mbox_alloc(hermon_state_t *state,
46 hermon_mboxlist_t *mblist, hermon_mbox_t **mb, uint_t mbox_wait);
47 static void hermon_impl_mbox_free(hermon_mboxlist_t *mblist,
48 hermon_mbox_t **mb);
49 static int hermon_impl_mboxlist_init(hermon_state_t *state,
50 hermon_mboxlist_t *mblist, uint_t num_mbox, hermon_rsrc_type_t type);
51 static void hermon_impl_mboxlist_fini(hermon_state_t *state,
52 hermon_mboxlist_t *mblist);
53 static int hermon_outstanding_cmd_alloc(hermon_state_t *state,
54 hermon_cmd_t **cmd_ptr, uint_t cmd_wait);
55 static void hermon_outstanding_cmd_free(hermon_state_t *state,
56 hermon_cmd_t **cmd_ptr);
57 static int hermon_write_hcr(hermon_state_t *state, hermon_cmd_post_t *cmdpost,
58 uint16_t token, int *hwerr);
59 static void hermon_mbox_sync(hermon_mbox_t *mbox, uint_t offset,
60 uint_t length, uint_t flag);
61 static void hermon_cmd_check_status(hermon_state_t *state, int status);
62
63 /*
64 * hermon_cmd_post()
65 * Context: Can be called from interrupt or base context.
66 *
67 * The "cp_flags" field in cmdpost
68 * is used to determine whether to wait for an available
69 * outstanding command (if necessary) or to return error.
70 */
71 int
72 hermon_cmd_post(hermon_state_t *state, hermon_cmd_post_t *cmdpost)
73 {
74 hermon_cmd_t *cmdptr;
75 int status, retry_cnt, retry_cnt2, hw_err;
76 uint16_t token;
77
78 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*cmdpost))
79
80 /* Determine if we are going to spin until completion */
81 if (cmdpost->cp_flags == HERMON_CMD_NOSLEEP_SPIN) {
82
83 /* Write the command to the HCR */
84 retry_cnt = HCA_PIO_RETRY_CNT;
85 do {
86 status = hermon_write_hcr(state, cmdpost, 0, &hw_err);
87 } while (status == HERMON_CMD_INTERNAL_ERR && retry_cnt-- > 0);
88
89 /* Check if there is an error status in hermon_write_hcr() */
90 if (status != HERMON_CMD_SUCCESS) {
91 /*
92 * If there is a HW error, call hermon_cmd_retry_ok()
93 * to check the side-effect of the operation retry.
94 */
95 if ((retry_cnt == HCA_PIO_RETRY_CNT &&
96 hw_err == HCA_PIO_OK) ||
97 !hermon_cmd_retry_ok(cmdpost, status)) {
98 hermon_cmd_check_status(state, status);
99 return (status);
100 }
101 /* Check if there is a transient internal error */
102 } else if (retry_cnt != HCA_PIO_RETRY_CNT) {
103 hermon_fm_ereport(state, HCA_IBA_ERR,
104 HCA_ERR_TRANSIENT);
105 }
106
107 } else { /* "HERMON_CMD_SLEEP_NOSPIN" */
108 ASSERT(HERMON_SLEEPFLAG_FOR_CONTEXT() != HERMON_NOSLEEP);
109
110 /* NOTE: Expect threads to be waiting in here */
111 status = hermon_outstanding_cmd_alloc(state, &cmdptr,
112 cmdpost->cp_flags);
113 if (status != HERMON_CMD_SUCCESS) {
114 return (status);
115 }
116 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*cmdptr))
117
118 retry_cnt = HCA_PIO_RETRY_CNT;
119 retry:
120 /*
121 * Set status to "HERMON_CMD_INVALID_STATUS". It is
122 * appropriate to do this here without the "cmd_comp_lock"
123 * because this register is overloaded. Later it will be
124 * used to indicate - through a change from this invalid
125 * value to some other value - that the condition variable
126 * has been signaled. Once it has, status will then contain
127 * the _real_ completion status
128 */
129 cmdptr->cmd_status = HERMON_CMD_INVALID_STATUS;
130
131 /* Write the command to the HCR */
132 token = (uint16_t)cmdptr->cmd_indx;
133 retry_cnt2 = HCA_PIO_RETRY_CNT;
134 do {
135 status = hermon_write_hcr(state, cmdpost, token,
136 &hw_err);
137 } while (status == HERMON_CMD_INTERNAL_ERR && retry_cnt2-- > 0);
138
139 /* Check if there is an error status in hermon_write_hcr() */
140 if (status != HERMON_CMD_SUCCESS) {
141 /*
142 * If there is a HW error, call hermon_cmd_retry_ok()
143 * to check the side-effect of the operation retry.
144 */
145 if ((retry_cnt == HCA_PIO_RETRY_CNT &&
146 hw_err == HCA_PIO_OK) ||
147 !hermon_cmd_retry_ok(cmdpost, status)) {
148 hermon_cmd_check_status(state, status);
149 hermon_outstanding_cmd_free(state, &cmdptr);
150 return (status);
151 }
152 /* Check if there is a transient internal error */
153 } else if (retry_cnt2 != HCA_PIO_RETRY_CNT) {
154 hermon_fm_ereport(state, HCA_IBA_ERR,
155 HCA_ERR_TRANSIENT);
156 }
157
158 /*
159 * cv_wait() on the "command_complete" condition variable.
160 * Note: We have the "__lock_lint" here to workaround warlock.
161 * Since warlock doesn't know that other parts of the Hermon
162 * may occasionally call this routine while holding their own
163 * locks, it complains about this cv_wait. In reality,
164 * however, the rest of the driver never calls this routine
165 * with a lock held unless they pass HERMON_CMD_NOSLEEP.
166 */
167 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*cmdptr))
168 mutex_enter(&cmdptr->cmd_comp_lock);
169 while (cmdptr->cmd_status == HERMON_CMD_INVALID_STATUS) {
170 #ifndef __lock_lint
171 cv_wait(&cmdptr->cmd_comp_cv, &cmdptr->cmd_comp_lock);
172 /* NOTE: EXPECT SEVERAL THREADS TO BE WAITING HERE */
173 #endif
174 }
175 mutex_exit(&cmdptr->cmd_comp_lock);
176 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*cmdptr))
177
178 /*
179 * Wake up after command completes (cv_signal). Read status
180 * from the command (success, fail, etc.). It is appropriate
181 * here (as above) to read the status field without the
182 * "cmd_comp_lock" because it is no longer being used to
183 * indicate whether the condition variable has been signaled
184 * (i.e. at this point we are certain that it already has).
185 */
186 status = cmdptr->cmd_status;
187
188 /* retry the operation if an internal error occurs */
189 if (status == HERMON_CMD_INTERNAL_ERR && retry_cnt-- > 0)
190 goto retry;
191
192 /* Save the "outparam" values into the cmdpost struct */
193 cmdpost->cp_outparm = cmdptr->cmd_outparm;
194
195 /*
196 * Add the command back to the "outstanding commands list".
197 * Signal the "cmd_list" condition variable, if necessary.
198 */
199 hermon_outstanding_cmd_free(state, &cmdptr);
200
201 /* Check if there is an error status in hermon_write_hcr() */
202 if (status != HERMON_CMD_SUCCESS) {
203 /*
204 * If there is a HW error, call hermon_cmd_retry_ok()
205 * to check the side-effect of the operation retry.
206 */
207 if ((retry_cnt == HCA_PIO_RETRY_CNT &&
208 hw_err == HCA_PIO_OK) ||
209 !hermon_cmd_retry_ok(cmdpost, status)) {
210 hermon_cmd_check_status(state, status);
211 cmn_err(CE_NOTE, "hermon%d: post cmd failed "
212 "opcode (0x%x) status (0x%x)\n",
213 state->hs_instance, cmdpost->cp_opcode,
214 status);
215 return (status);
216 }
217 /* Check if there is a transient internal error */
218 } else if (retry_cnt != HCA_PIO_RETRY_CNT) {
219 hermon_fm_ereport(state, HCA_IBA_ERR,
220 HCA_ERR_TRANSIENT);
221 }
222 }
223
224 return (HERMON_CMD_SUCCESS);
225 }
226
227 /*
228 * hermon_cmd_check_status()
229 * Context: Can be called from interrupt or base
230 *
231 * checks the status returned from write_hcr and does the right
232 * notice to the console, if any
233 */
234 static void
235 hermon_cmd_check_status(hermon_state_t *state, int status)
236 {
237 switch (status) {
238 case HERMON_CMD_TIMEOUT_TOGGLE:
239 HERMON_FMANOTE(state, HERMON_FMA_TOTOG);
240 hermon_fm_ereport(state, HCA_IBA_ERR,
241 HCA_ERR_NON_FATAL);
242 break;
243
244 case HERMON_CMD_TIMEOUT_GOBIT:
245 HERMON_FMANOTE(state, HERMON_FMA_GOBIT);
246 hermon_fm_ereport(state, HCA_IBA_ERR,
247 HCA_ERR_NON_FATAL);
248 break;
249
250 case HERMON_CMD_INSUFF_RSRC:
251 HERMON_FMANOTE(state, HERMON_FMA_RSRC);
252 break;
253
254 case HERMON_CMD_INVALID_STATUS:
255 HERMON_FMANOTE(state, HERMON_FMA_CMDINV);
256 hermon_fm_ereport(state, HCA_IBA_ERR,
257 HCA_ERR_NON_FATAL);
258 break;
259
260 case HERMON_CMD_INTERNAL_ERR:
261 HERMON_FMANOTE(state, HERMON_FMA_HCRINT);
262 hermon_fm_ereport(state, HCA_IBA_ERR,
263 HCA_ERR_NON_FATAL);
264 break;
265
266 case HERMON_CMD_BAD_NVMEM:
267 /*
268 * No need of an ereport here since this case
269 * is treated as a degradation later.
270 */
271 HERMON_FMANOTE(state, HERMON_FMA_NVMEM);
272 break;
273
274 default:
275 break;
276 }
277 }
278
279 /*
280 * hermon_mbox_alloc()
281 * Context: Can be called from interrupt or base context.
282 *
283 * The "mbox_wait" parameter is used to determine whether to
284 * wait for a mailbox to become available or not.
285 */
286 int
287 hermon_mbox_alloc(hermon_state_t *state, hermon_mbox_info_t *mbox_info,
288 uint_t mbox_wait)
289 {
290 int status;
291 uint_t sleep_context;
292
293 sleep_context = HERMON_SLEEPFLAG_FOR_CONTEXT();
294
295 /* Allocate an "In" mailbox */
296 if (mbox_info->mbi_alloc_flags & HERMON_ALLOC_INMBOX) {
297 /* Determine correct mboxlist based on calling context */
298 if (sleep_context == HERMON_NOSLEEP) {
299 status = hermon_impl_mbox_alloc(state,
300 &state->hs_in_intr_mblist,
301 &mbox_info->mbi_in, mbox_wait);
302
303 ASSERT(status == HERMON_CMD_SUCCESS);
304 } else {
305 /* NOTE: Expect threads to be waiting in here */
306 status = hermon_impl_mbox_alloc(state,
307 &state->hs_in_mblist, &mbox_info->mbi_in,
308 mbox_wait);
309 if (status != HERMON_CMD_SUCCESS) {
310 return (status);
311 }
312 }
313
314 }
315
316 /* Allocate an "Out" mailbox */
317 if (mbox_info->mbi_alloc_flags & HERMON_ALLOC_OUTMBOX) {
318 /* Determine correct mboxlist based on calling context */
319 if (sleep_context == HERMON_NOSLEEP) {
320 status = hermon_impl_mbox_alloc(state,
321 &state->hs_out_intr_mblist,
322 &mbox_info->mbi_out, mbox_wait);
323
324 ASSERT(status == HERMON_CMD_SUCCESS);
325 } else {
326 /* NOTE: Expect threads to be waiting in here */
327 status = hermon_impl_mbox_alloc(state,
328 &state->hs_out_mblist, &mbox_info->mbi_out,
329 mbox_wait);
330 if (status != HERMON_CMD_SUCCESS) {
331 /* If we allocated an "In" mailbox, free it */
332 if (mbox_info->mbi_alloc_flags &
333 HERMON_ALLOC_INMBOX) {
334 hermon_impl_mbox_free(
335 &state->hs_in_mblist,
336 &mbox_info->mbi_in);
337 }
338 return (status);
339 }
340 }
341 }
342
343 /* Store appropriate context in mbox_info */
344 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(mbox_info->mbi_sleep_context))
345 mbox_info->mbi_sleep_context = sleep_context;
346
347 return (HERMON_CMD_SUCCESS);
348 }
349
350
351 /*
352 * hermon_mbox_free()
353 * Context: Can be called from interrupt or base context.
354 */
355 void
356 hermon_mbox_free(hermon_state_t *state, hermon_mbox_info_t *mbox_info)
357 {
358 /*
359 * The mailbox has to be freed in the same context from which it was
360 * allocated. The context is stored in the mbox_info at
361 * hermon_mbox_alloc() time. We check the stored context against the
362 * current context here.
363 */
364 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(mbox_info->mbi_sleep_context))
365 ASSERT(mbox_info->mbi_sleep_context == HERMON_SLEEPFLAG_FOR_CONTEXT());
366
367 /* Determine correct mboxlist based on calling context */
368 if (mbox_info->mbi_sleep_context == HERMON_NOSLEEP) {
369 /* Free the intr "In" mailbox */
370 if (mbox_info->mbi_alloc_flags & HERMON_ALLOC_INMBOX) {
371 hermon_impl_mbox_free(&state->hs_in_intr_mblist,
372 &mbox_info->mbi_in);
373 }
374
375 /* Free the intr "Out" mailbox */
376 if (mbox_info->mbi_alloc_flags & HERMON_ALLOC_OUTMBOX) {
377 hermon_impl_mbox_free(&state->hs_out_intr_mblist,
378 &mbox_info->mbi_out);
379 }
380 } else {
381 /* Free the "In" mailbox */
382 if (mbox_info->mbi_alloc_flags & HERMON_ALLOC_INMBOX) {
383 hermon_impl_mbox_free(&state->hs_in_mblist,
384 &mbox_info->mbi_in);
385 }
386
387 /* Free the "Out" mailbox */
388 if (mbox_info->mbi_alloc_flags & HERMON_ALLOC_OUTMBOX) {
389 hermon_impl_mbox_free(&state->hs_out_mblist,
390 &mbox_info->mbi_out);
391 }
392 }
393 }
394
395
396
397 /*
398 * hermon_cmd_complete_handler()
399 * Context: Called only from interrupt context.
400 */
401 /* ARGSUSED */
402 int
403 hermon_cmd_complete_handler(hermon_state_t *state, hermon_eqhdl_t eq,
404 hermon_hw_eqe_t *eqe)
405 {
406 hermon_cmd_t *cmdp;
407
408 /*
409 * Find the outstanding command pointer based on value returned
410 * in "token"
411 */
412 cmdp = &state->hs_cmd_list.cml_cmd[HERMON_EQE_CMDTOKEN_GET(eq, eqe)];
413
414 /* Signal the waiting thread */
415 mutex_enter(&cmdp->cmd_comp_lock);
416 cmdp->cmd_outparm = ((uint64_t)HERMON_EQE_CMDOUTP0_GET(eq, eqe) << 32) |
417 HERMON_EQE_CMDOUTP1_GET(eq, eqe);
418 cmdp->cmd_status = HERMON_EQE_CMDSTATUS_GET(eq, eqe);
419
420 cv_signal(&cmdp->cmd_comp_cv);
421 mutex_exit(&cmdp->cmd_comp_lock);
422
423 return (DDI_SUCCESS);
424 }
425
426
427 /*
428 * hermon_inmbox_list_init()
429 * Context: Only called from attach() path context
430 */
431 int
432 hermon_inmbox_list_init(hermon_state_t *state)
433 {
434 int status;
435 uint_t num_inmbox;
436
437 /* Initialize the "In" mailbox list */
438 num_inmbox = (1 << state->hs_cfg_profile->cp_log_num_inmbox);
439 status = hermon_impl_mboxlist_init(state, &state->hs_in_mblist,
440 num_inmbox, HERMON_IN_MBOX);
441 if (status != DDI_SUCCESS) {
442 return (DDI_FAILURE);
443 }
444
445 return (DDI_SUCCESS);
446 }
447
448
449 /*
450 * hermon_intr_inmbox_list_init()
451 * Context: Only called from attach() path context
452 */
453 int
454 hermon_intr_inmbox_list_init(hermon_state_t *state)
455 {
456 int status;
457 uint_t num_inmbox;
458
459 /* Initialize the interrupt "In" mailbox list */
460 num_inmbox = (1 << state->hs_cfg_profile->cp_log_num_intr_inmbox);
461 status = hermon_impl_mboxlist_init(state, &state->hs_in_intr_mblist,
462 num_inmbox, HERMON_INTR_IN_MBOX);
463 if (status != DDI_SUCCESS) {
464 return (DDI_FAILURE);
465 }
466
467 return (DDI_SUCCESS);
468 }
469
470
471 /*
472 * hermon_outmbox_list_init()
473 * Context: Only called from attach() path context
474 */
475 int
476 hermon_outmbox_list_init(hermon_state_t *state)
477 {
478 int status;
479 uint_t num_outmbox;
480
481 /* Initialize the "Out" mailbox list */
482 num_outmbox = (1 << state->hs_cfg_profile->cp_log_num_outmbox);
483 status = hermon_impl_mboxlist_init(state, &state->hs_out_mblist,
484 num_outmbox, HERMON_OUT_MBOX);
485 if (status != DDI_SUCCESS) {
486 return (DDI_FAILURE);
487 }
488
489 return (DDI_SUCCESS);
490 }
491
492
493 /*
494 * hermon_intr_outmbox_list_init()
495 * Context: Only called from attach() path context
496 */
497 int
498 hermon_intr_outmbox_list_init(hermon_state_t *state)
499 {
500 int status;
501 uint_t num_outmbox;
502
503 /* Initialize the interrupts "Out" mailbox list */
504 num_outmbox = (1 << state->hs_cfg_profile->cp_log_num_intr_outmbox);
505 status = hermon_impl_mboxlist_init(state, &state->hs_out_intr_mblist,
506 num_outmbox, HERMON_INTR_OUT_MBOX);
507 if (status != DDI_SUCCESS) {
508 return (DDI_FAILURE);
509 }
510
511 return (DDI_SUCCESS);
512 }
513
514
515 /*
516 * hermon_inmbox_list_fini()
517 * Context: Only called from attach() and/or detach() path contexts
518 */
519 void
520 hermon_inmbox_list_fini(hermon_state_t *state)
521 {
522 /* Free up the "In" mailbox list */
523 hermon_impl_mboxlist_fini(state, &state->hs_in_mblist);
524 }
525
526
527 /*
528 * hermon_intr_inmbox_list_fini()
529 * Context: Only called from attach() and/or detach() path contexts
530 */
531 void
532 hermon_intr_inmbox_list_fini(hermon_state_t *state)
533 {
534 /* Free up the interupts "In" mailbox list */
535 hermon_impl_mboxlist_fini(state, &state->hs_in_intr_mblist);
536 }
537
538
539 /*
540 * hermon_outmbox_list_fini()
541 * Context: Only called from attach() and/or detach() path contexts
542 */
543 void
544 hermon_outmbox_list_fini(hermon_state_t *state)
545 {
546 /* Free up the "Out" mailbox list */
547 hermon_impl_mboxlist_fini(state, &state->hs_out_mblist);
548 }
549
550
551 /*
552 * hermon_intr_outmbox_list_fini()
553 * Context: Only called from attach() and/or detach() path contexts
554 */
555 void
556 hermon_intr_outmbox_list_fini(hermon_state_t *state)
557 {
558 /* Free up the interrupt "Out" mailbox list */
559 hermon_impl_mboxlist_fini(state, &state->hs_out_intr_mblist);
560 }
561
562
563 /*
564 * hermon_impl_mbox_alloc()
565 * Context: Can be called from interrupt or base context.
566 */
567 static int
568 hermon_impl_mbox_alloc(hermon_state_t *state, hermon_mboxlist_t *mblist,
569 hermon_mbox_t **mb, uint_t mbox_wait)
570 {
571 hermon_mbox_t *mbox_ptr;
572 uint_t index, next, prev;
573 uint_t count, countmax;
574
575 /*
576 * If the mailbox list is empty, then wait (if appropriate in the
577 * current context). Otherwise, grab the next available mailbox.
578 */
579 if (mbox_wait == HERMON_NOSLEEP) {
580 count = 0;
581 countmax = state->hs_cfg_profile->cp_cmd_poll_max;
582
583 mutex_enter(&mblist->mbl_lock);
584 mblist->mbl_pollers++;
585 while (mblist->mbl_entries_free == 0) {
586 mutex_exit(&mblist->mbl_lock);
587 /* Delay loop polling for an available mbox */
588 if (++count > countmax) {
589 return (HERMON_CMD_INSUFF_RSRC);
590 }
591
592 /* Delay before polling for mailbox again */
593 drv_usecwait(state->hs_cfg_profile->cp_cmd_poll_delay);
594 mutex_enter(&mblist->mbl_lock);
595 }
596 mblist->mbl_pollers--;
597
598 /* HERMON_SLEEP */
599 } else {
600 /*
601 * Grab lock here as we prepare to cv_wait if needed.
602 */
603 mutex_enter(&mblist->mbl_lock);
604 while (mblist->mbl_entries_free == 0) {
605 /*
606 * Wait (on cv) for a mailbox to become free. Note:
607 * Just as we do above in hermon_cmd_post(), we also
608 * have the "__lock_lint" here to workaround warlock.
609 * Warlock doesn't know that other parts of the Hermon
610 * may occasionally call this routine while holding
611 * their own locks, so it complains about this cv_wait.
612 * In reality, however, the rest of the driver never
613 * calls this routine with a lock held unless they pass
614 * HERMON_CMD_NOSLEEP.
615 */
616 mblist->mbl_waiters++;
617 #ifndef __lock_lint
618 cv_wait(&mblist->mbl_cv, &mblist->mbl_lock);
619 #endif
620 }
621 }
622
623 /* Grab the next available mailbox from list */
624 mbox_ptr = mblist->mbl_mbox;
625 index = mblist->mbl_head_indx;
626 next = mbox_ptr[index].mb_next;
627 prev = mbox_ptr[index].mb_prev;
628
629 /* Remove it from the mailbox list */
630 mblist->mbl_mbox[next].mb_prev = prev;
631 mblist->mbl_mbox[prev].mb_next = next;
632 mblist->mbl_head_indx = next;
633
634 /* Update the "free" count and return the mailbox pointer */
635 mblist->mbl_entries_free--;
636 *mb = &mbox_ptr[index];
637
638 mutex_exit(&mblist->mbl_lock);
639
640 return (HERMON_CMD_SUCCESS);
641 }
642
643
644 /*
645 * hermon_impl_mbox_free()
646 * Context: Can be called from interrupt or base context.
647 */
648 static void
649 hermon_impl_mbox_free(hermon_mboxlist_t *mblist, hermon_mbox_t **mb)
650 {
651 uint_t mbox_indx;
652
653 mutex_enter(&mblist->mbl_lock);
654
655 /* Pull the "index" from mailbox entry */
656 mbox_indx = (*mb)->mb_indx;
657
658 /*
659 * If mailbox list is not empty, then insert the entry. Otherwise,
660 * this is the only entry. So update the pointers appropriately.
661 */
662 if (mblist->mbl_entries_free++ != 0) {
663 /* Update the current mailbox */
664 (*mb)->mb_next = mblist->mbl_head_indx;
665 (*mb)->mb_prev = mblist->mbl_tail_indx;
666
667 /* Update head and tail mailboxes */
668 mblist->mbl_mbox[mblist->mbl_head_indx].mb_prev = mbox_indx;
669 mblist->mbl_mbox[mblist->mbl_tail_indx].mb_next = mbox_indx;
670
671 /* Update tail index */
672 mblist->mbl_tail_indx = mbox_indx;
673
674 } else {
675 /* Update the current mailbox */
676 (*mb)->mb_next = mbox_indx;
677 (*mb)->mb_prev = mbox_indx;
678
679 /* Update head and tail indexes */
680 mblist->mbl_tail_indx = mbox_indx;
681 mblist->mbl_head_indx = mbox_indx;
682 }
683
684 /*
685 * Because we can have both waiters (SLEEP treads waiting for a
686 * cv_signal to continue processing) and pollers (NOSLEEP treads
687 * polling for a mailbox to become available), we try to share CPU time
688 * between them. We do this by signalling the waiters only every other
689 * call to mbox_free. This gives the pollers a chance to get some CPU
690 * time to do their command. If we signalled every time, the pollers
691 * would have a much harder time getting CPU time.
692 *
693 * If there are waiters and no pollers, then we signal always.
694 *
695 * Otherwise, if there are either no waiters, there may in fact be
696 * pollers, so we do not signal in that case.
697 */
698 if (mblist->mbl_pollers > 0 && mblist->mbl_waiters > 0) {
699 /* flip the signal value */
700 mblist->mbl_signal = (mblist->mbl_signal + 1) % 2;
701 } else if (mblist->mbl_waiters > 0) {
702 mblist->mbl_signal = 1;
703 } else {
704 mblist->mbl_signal = 0;
705 }
706
707 /*
708 * Depending on the conditions in the previous check, we signal only if
709 * we are supposed to.
710 */
711 if (mblist->mbl_signal) {
712 mblist->mbl_waiters--;
713 cv_signal(&mblist->mbl_cv);
714 }
715
716 /* Clear out the mailbox entry pointer */
717 *mb = NULL;
718
719 mutex_exit(&mblist->mbl_lock);
720 }
721
722
723 /*
724 * hermon_impl_mboxlist_init()
725 * Context: Only called from attach() path context
726 */
727 static int
728 hermon_impl_mboxlist_init(hermon_state_t *state, hermon_mboxlist_t *mblist,
729 uint_t num_mbox, hermon_rsrc_type_t type)
730 {
731 hermon_rsrc_t *rsrc;
732 ddi_dma_cookie_t dma_cookie;
733 uint_t dma_cookiecnt;
734 int status, i;
735
736 /* Allocate the memory for the mailbox entries list */
737 mblist->mbl_list_sz = num_mbox;
738 mblist->mbl_mbox = kmem_zalloc(mblist->mbl_list_sz *
739 sizeof (hermon_mbox_t), KM_SLEEP);
740
741 /* Initialize the mailbox entries list */
742 mblist->mbl_head_indx = 0;
743 mblist->mbl_tail_indx = mblist->mbl_list_sz - 1;
744 mblist->mbl_entries_free = mblist->mbl_list_sz;
745 mblist->mbl_waiters = 0;
746 mblist->mbl_num_alloc = 0;
747
748 /* Set up the mailbox list's cv and mutex */
749 mutex_init(&mblist->mbl_lock, NULL, MUTEX_DRIVER,
750 DDI_INTR_PRI(state->hs_intrmsi_pri));
751 cv_init(&mblist->mbl_cv, NULL, CV_DRIVER, NULL);
752
753 /* Initialize the mailbox list entries */
754 for (i = 0; i < mblist->mbl_list_sz; i++) {
755 /* Allocate resources for the mailbox */
756 status = hermon_rsrc_alloc(state, type, 1, HERMON_SLEEP,
757 &rsrc);
758 if (status != DDI_SUCCESS) {
759 /* Jump to cleanup and return error */
760 goto mboxlist_init_fail;
761 }
762
763 /* Save away the mailbox resource info */
764 mblist->mbl_mbox[i].mb_rsrcptr = rsrc;
765 mblist->mbl_mbox[i].mb_addr = rsrc->hr_addr;
766 mblist->mbl_mbox[i].mb_acchdl = rsrc->hr_acchdl;
767
768 /*
769 * Get a PCI mapped address for each mailbox. Note: this
770 * uses the ddi_dma_handle return from the resource
771 * allocation routine
772 */
773 status = ddi_dma_addr_bind_handle(rsrc->hr_dmahdl, NULL,
774 rsrc->hr_addr, rsrc->hr_len,
775 (DDI_DMA_RDWR | DDI_DMA_CONSISTENT),
776 DDI_DMA_SLEEP, NULL, &dma_cookie, &dma_cookiecnt);
777 if (status != DDI_SUCCESS) {
778 /* Jump to cleanup and return error */
779 hermon_rsrc_free(state, &rsrc);
780 goto mboxlist_init_fail;
781 }
782
783 /* Save away the mapped address for the mailbox */
784 mblist->mbl_mbox[i].mb_mapaddr = dma_cookie.dmac_laddress;
785
786 /* Make each entry point to the "next" and "prev" entries */
787 mblist->mbl_mbox[i].mb_next = i+1;
788 mblist->mbl_mbox[i].mb_prev = i-1;
789 mblist->mbl_mbox[i].mb_indx = i;
790 mblist->mbl_num_alloc = i + 1;
791 }
792
793 /* Make the "head" and "tail" entries point to each other */
794 mblist->mbl_mbox[mblist->mbl_head_indx].mb_prev =
795 mblist->mbl_tail_indx;
796 mblist->mbl_mbox[mblist->mbl_tail_indx].mb_next =
797 mblist->mbl_head_indx;
798
799 return (DDI_SUCCESS);
800
801 mboxlist_init_fail:
802 hermon_impl_mboxlist_fini(state, mblist);
803
804 return (DDI_FAILURE);
805 }
806
807
808 /*
809 * hermon_impl_mboxlist_fini()
810 * Context: Only called from attach() and/or detach() path contexts
811 */
812 static void
813 hermon_impl_mboxlist_fini(hermon_state_t *state, hermon_mboxlist_t *mblist)
814 {
815 hermon_rsrc_t *rsrc;
816 int i, status;
817
818 /* Release the resources for each of the mailbox list entries */
819 for (i = 0; i < mblist->mbl_num_alloc; i++) {
820 rsrc = mblist->mbl_mbox[i].mb_rsrcptr;
821
822 /*
823 * First, unbind the DMA memory for the mailbox
824 *
825 * Note: The only way ddi_dma_unbind_handle() currently
826 * can return an error is if the handle passed in is invalid.
827 * Since this should never happen, we choose to return void
828 * from this function! If this does return an error,
829 * however, then we print a warning message to the console.
830 */
831 status = ddi_dma_unbind_handle(rsrc->hr_dmahdl);
832 if (status != DDI_SUCCESS) {
833 HERMON_WARNING(state, "failed to unbind DMA mapping");
834 return;
835 }
836
837 /* Next, free the mailbox resource */
838 hermon_rsrc_free(state, &rsrc);
839 }
840
841 /* Destroy the mailbox list mutex and cv */
842 mutex_destroy(&mblist->mbl_lock);
843 cv_destroy(&mblist->mbl_cv);
844
845 /* Free up the memory for tracking the mailbox list */
846 kmem_free(mblist->mbl_mbox, mblist->mbl_list_sz *
847 sizeof (hermon_mbox_t));
848 }
849
850
851 /*
852 * hermon_outstanding_cmd_alloc()
853 * Context: Can be called only from base context.
854 */
855 static int
856 hermon_outstanding_cmd_alloc(hermon_state_t *state, hermon_cmd_t **cmd_ptr,
857 uint_t cmd_wait)
858 {
859 hermon_cmdlist_t *cmd_list;
860 uint_t next, prev, head;
861
862 cmd_list = &state->hs_cmd_list;
863 mutex_enter(&cmd_list->cml_lock);
864
865 /* Ensure that outstanding commands are supported */
866 ASSERT(cmd_list->cml_num_alloc != 0);
867
868 /*
869 * If the outstanding command list is empty, then wait (if
870 * appropriate in the current context). Otherwise, grab the
871 * next available command.
872 */
873 while (cmd_list->cml_entries_free == 0) {
874 /* No free commands */
875 if (cmd_wait == HERMON_NOSLEEP) {
876 mutex_exit(&cmd_list->cml_lock);
877 return (HERMON_CMD_INSUFF_RSRC);
878 }
879
880 /*
881 * Wait (on cv) for a command to become free. Note: Just
882 * as we do above in hermon_cmd_post(), we also have the
883 * "__lock_lint" here to workaround warlock. Warlock doesn't
884 * know that other parts of the Hermon may occasionally call
885 * this routine while holding their own locks, so it complains
886 * about this cv_wait. In reality, however, the rest of the
887 * driver never calls this routine with a lock held unless
888 * they pass HERMON_CMD_NOSLEEP.
889 */
890 cmd_list->cml_waiters++;
891 #ifndef __lock_lint
892 cv_wait(&cmd_list->cml_cv, &cmd_list->cml_lock);
893 #endif
894 }
895
896 /* Grab the next available command from the list */
897 head = cmd_list->cml_head_indx;
898 *cmd_ptr = &cmd_list->cml_cmd[head];
899 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(**cmd_ptr))
900 next = (*cmd_ptr)->cmd_next;
901 prev = (*cmd_ptr)->cmd_prev;
902 (*cmd_ptr)->cmd_status = HERMON_CMD_INVALID_STATUS;
903
904 /* Remove it from the command list */
905 cmd_list->cml_cmd[next].cmd_prev = prev;
906 cmd_list->cml_cmd[prev].cmd_next = next;
907 cmd_list->cml_head_indx = next;
908
909 /* Update the "free" count and return */
910 cmd_list->cml_entries_free--;
911
912 mutex_exit(&cmd_list->cml_lock);
913
914 return (HERMON_CMD_SUCCESS);
915 }
916
917
918 /*
919 * hermon_outstanding_cmd_free()
920 * Context: Can be called only from base context.
921 */
922 static void
923 hermon_outstanding_cmd_free(hermon_state_t *state, hermon_cmd_t **cmd_ptr)
924 {
925 hermon_cmdlist_t *cmd_list;
926 uint_t cmd_indx;
927
928 cmd_list = &state->hs_cmd_list;
929 mutex_enter(&cmd_list->cml_lock);
930
931 /* Pull the "index" from command entry */
932 cmd_indx = (*cmd_ptr)->cmd_indx;
933
934 /*
935 * If outstanding command list is not empty, then insert the entry.
936 * Otherwise, this is the only entry. So update the pointers
937 * appropriately.
938 */
939 if (cmd_list->cml_entries_free++ != 0) {
940 /* Update the current command */
941 (*cmd_ptr)->cmd_next = cmd_list->cml_head_indx;
942 (*cmd_ptr)->cmd_prev = cmd_list->cml_tail_indx;
943
944 /* Update head and tail commands */
945 cmd_list->cml_cmd[cmd_list->cml_head_indx].cmd_prev = cmd_indx;
946 cmd_list->cml_cmd[cmd_list->cml_tail_indx].cmd_next = cmd_indx;
947
948 /* Update tail index */
949 cmd_list->cml_tail_indx = cmd_indx;
950
951 } else {
952 /* Update the current command */
953 (*cmd_ptr)->cmd_next = cmd_indx;
954 (*cmd_ptr)->cmd_prev = cmd_indx;
955
956 /* Update head and tail indexes */
957 cmd_list->cml_head_indx = cmd_indx;
958 cmd_list->cml_tail_indx = cmd_indx;
959 }
960
961 /* If there are threads waiting, signal one of them */
962 if (cmd_list->cml_waiters > 0) {
963 cmd_list->cml_waiters--;
964 cv_signal(&cmd_list->cml_cv);
965 }
966
967 /* Clear out the command entry pointer */
968 *cmd_ptr = NULL;
969
970 mutex_exit(&cmd_list->cml_lock);
971 }
972
973
974 /*
975 * hermon_write_hcr()
976 * Context: Can be called from interrupt or base context.
977 */
978 static int
979 hermon_write_hcr(hermon_state_t *state, hermon_cmd_post_t *cmdpost,
980 uint16_t token, int *hw_err)
981 {
982 hermon_hw_hcr_t *hcr;
983 uint_t status, count, countmax;
984 uint64_t hcrreg;
985 uint64_t togmask;
986 ddi_acc_handle_t cmdhdl = hermon_get_cmdhdl(state);
987 boolean_t hw_error = B_FALSE;
988
989 /* initialize the FMA retry loop */
990 hermon_pio_init(fm_loop_cnt, fm_status, fm_test);
991
992 /*
993 * Grab the "HCR access" lock if the driver is not in
994 * fastreboot. In fastreboot, this function is called
995 * with the single thread but in high interrupt context
996 * (so that this mutex lock cannot be used).
997 */
998 #ifdef __lock_lint
999 mutex_enter(&state->hs_cmd_regs.hcr_lock);
1000 #else
1001 if (!HERMON_IN_FASTREBOOT(state)) {
1002 mutex_enter(&state->hs_cmd_regs.hcr_lock);
1003 }
1004 #endif
1005 hcr = state->hs_cmd_regs.hcr;
1006
1007 /*
1008 * First, check the "go" bit to see if any previous hcr usage is
1009 * complete. As long as it is set then we must continue to poll.
1010 */
1011
1012 countmax = state->hs_cfg_profile->cp_cmd_poll_max;
1013 togmask = (state->hs_cmd_toggle & 0x01) << HERMON_HCR_CMD_T_SHFT;
1014
1015 /* the FMA retry loop starts. */
1016 hermon_pio_start(state, cmdhdl, pio_error, fm_loop_cnt, fm_status,
1017 fm_test);
1018
1019 count = 0;
1020 for (;;) {
1021 hcrreg = ddi_get32(cmdhdl, &hcr->cmd);
1022
1023 /* If "go" bit is clear and toggle reset, then done */
1024 if (((hcrreg & HERMON_HCR_CMD_GO_MASK) == 0) &&
1025 ((hcrreg & HERMON_HCR_CMD_T_MASK) == togmask)) {
1026 break;
1027 }
1028 /* Delay before polling the "go" bit again */
1029 drv_usecwait(state->hs_cfg_profile->cp_cmd_poll_delay);
1030
1031 /*
1032 * If we poll more than the maximum number of times, then
1033 * return a "timeout" error.
1034 */
1035 if (++count > countmax) {
1036 #ifdef __lock_lint
1037 mutex_exit(&state->hs_cmd_regs.hcr_lock);
1038 #else
1039 if (!HERMON_IN_FASTREBOOT(state)) {
1040 mutex_exit(&state->hs_cmd_regs.hcr_lock);
1041 }
1042 #endif
1043 cmn_err(CE_NOTE, "write_hcr: cannot start cmd");
1044 return (HERMON_CMD_TIMEOUT_GOBIT);
1045 }
1046 }
1047
1048 /* the FMA retry loop ends. */
1049 hermon_pio_end(state, cmdhdl, pio_error, fm_loop_cnt, fm_status,
1050 fm_test);
1051
1052 /* check if there is a transient error */
1053 if (fm_loop_cnt != HCA_PIO_RETRY_CNT) {
1054 hw_error = B_TRUE;
1055 }
1056
1057 /* succeeded, so update the cmd counter for this cmd's completion */
1058 state->hs_cmd_toggle++;
1059 togmask = (state->hs_cmd_toggle & 0x01) << HERMON_HCR_CMD_T_SHFT;
1060
1061 /* the FMA retry loop starts. */
1062 hermon_pio_start(state, cmdhdl, pio_error, fm_loop_cnt, fm_status,
1063 fm_test);
1064
1065 /* Write "inparam" as a 64-bit quantity */
1066 ddi_put64(cmdhdl, (uint64_t *)(void *)&hcr->in_param0,
1067 cmdpost->cp_inparm);
1068
1069 /* Write "inmod" and 32-bits of "outparam" as 64-bit */
1070 hcrreg = ((uint64_t)cmdpost->cp_inmod << 32);
1071 hcrreg = hcrreg | (cmdpost->cp_outparm >> 32);
1072
1073 ddi_put64(cmdhdl, (uint64_t *)(void *)&hcr->input_modifier, hcrreg);
1074
1075 /* Write the other 32-bits of "outparam" and "token" as 64-bit */
1076 hcrreg = (cmdpost->cp_outparm << 32);
1077 hcrreg = hcrreg | ((uint32_t)token << HERMON_HCR_TOKEN_SHIFT);
1078
1079 ddi_put64(cmdhdl, (uint64_t *)(void *)&hcr->out_param1, hcrreg);
1080
1081 /* Then setup the final hcrreg to hit doorbell (i.e. "go" bit) */
1082 hcrreg = HERMON_HCR_CMD_GO_MASK;
1083 /* Then set the toggle bit for this command */
1084 hcrreg |= (state->hs_cmd_toggle & 0x01) << HERMON_HCR_CMD_T_SHFT;
1085 if (cmdpost->cp_flags == HERMON_CMD_SLEEP_NOSPIN) {
1086 hcrreg = hcrreg | HERMON_HCR_CMD_E_MASK;
1087 }
1088 hcrreg = hcrreg | (cmdpost->cp_opmod << HERMON_HCR_CMD_OPMOD_SHFT);
1089 hcrreg = hcrreg | (cmdpost->cp_opcode);
1090
1091 /* Write the doorbell to the HCR */
1092 ddi_put32(cmdhdl, &hcr->cmd, hcrreg);
1093
1094 /* the FMA retry loop ends. */
1095 hermon_pio_end(state, cmdhdl, pio_error, fm_loop_cnt, fm_status,
1096 fm_test);
1097
1098 /* check if there is a transient error */
1099 if (fm_loop_cnt != HCA_PIO_RETRY_CNT) {
1100 hw_error = B_TRUE;
1101 }
1102
1103 /*
1104 * In the SPIN case we read the HCR and check the "go" bit. For the
1105 * NOSPIN case we do not have to poll, we simply release the HCR lock
1106 * and return.
1107 */
1108 if (cmdpost->cp_flags == HERMON_CMD_NOSLEEP_SPIN) {
1109
1110 countmax = (state->hs_cfg_profile->cp_cmd_poll_max << 4);
1111
1112 /* the FMA retry loop starts. */
1113 hermon_pio_start(state, cmdhdl, pio_error, fm_loop_cnt,
1114 fm_status, fm_test);
1115
1116 count = 0;
1117 for (;;) {
1118 hcrreg = ddi_get32(cmdhdl, &hcr->cmd);
1119
1120 /* If "go" bit is clear and toggle reset, then done */
1121 if (((hcrreg & HERMON_HCR_CMD_GO_MASK) == 0) &&
1122 ((hcrreg & HERMON_HCR_CMD_T_MASK) == togmask)) {
1123 break;
1124 }
1125 /* Delay before polling the "go" bit again */
1126 drv_usecwait(state->hs_cfg_profile->cp_cmd_poll_delay);
1127
1128 /*
1129 * If we poll more than the maximum number of times,
1130 * then return a "timeout" error.
1131 */
1132 if (++count > countmax) {
1133 #ifdef __lock_lint
1134 mutex_exit(&state-> hs_cmd_regs.hcr_lock);
1135 #else
1136 if (!HERMON_IN_FASTREBOOT(state)) {
1137 mutex_exit(&state->
1138 hs_cmd_regs.hcr_lock);
1139 }
1140 #endif
1141 cmn_err(CE_NOTE,
1142 "write_hcr: cannot complete cmd");
1143 return (HERMON_CMD_TIMEOUT_GOBIT);
1144 }
1145 }
1146
1147 /* Pull out the "status" bits from the HCR */
1148 status = (hcrreg >> HERMON_HCR_CMD_STATUS_SHFT);
1149
1150 /*
1151 * Read the "outparam" value. Note: we have to read "outparam"
1152 * as two separate 32-bit reads because the field in the HCR is
1153 * not 64-bit aligned.
1154 */
1155 hcrreg = ddi_get32(cmdhdl, &hcr->out_param0);
1156 cmdpost->cp_outparm = hcrreg << 32;
1157 hcrreg = ddi_get32(cmdhdl, &hcr->out_param1);
1158 cmdpost->cp_outparm |= hcrreg;
1159
1160 /* the FMA retry loop ends. */
1161 hermon_pio_end(state, cmdhdl, pio_error, fm_loop_cnt, fm_status,
1162 fm_test);
1163
1164 /* check if there is a transient error */
1165 if (fm_loop_cnt != HCA_PIO_RETRY_CNT) {
1166 hw_error = B_TRUE;
1167 }
1168
1169 /* END SPIN */
1170 } else { /* NOSPIN */
1171 status = HERMON_CMD_SUCCESS;
1172 }
1173
1174 /* Drop the "HCR access" lock */
1175 #ifdef __lock_lint
1176 mutex_exit(&state->hs_cmd_regs.hcr_lock);
1177 #else
1178 if (!HERMON_IN_FASTREBOOT(state)) {
1179 mutex_exit(&state->hs_cmd_regs.hcr_lock);
1180 }
1181 #endif
1182 if (hw_error == B_TRUE) {
1183 *hw_err = HCA_PIO_TRANSIENT;
1184 } else {
1185 *hw_err = HCA_PIO_OK;
1186 }
1187 #ifdef FMA_TEST
1188 if (hermon_test_num == -3) {
1189 status = HERMON_CMD_INTERNAL_ERR;
1190 }
1191 #endif
1192 return (status);
1193
1194 pio_error:
1195 #ifdef __lock_lint
1196 mutex_exit(&state->hs_cmd_regs.hcr_lock);
1197 #else
1198 if (!HERMON_IN_FASTREBOOT(state)) {
1199 mutex_exit(&state->hs_cmd_regs.hcr_lock);
1200 }
1201 #endif
1202 hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_NON_FATAL);
1203 *hw_err = HCA_PIO_PERSISTENT;
1204 return (HERMON_CMD_INVALID_STATUS);
1205 }
1206
1207
1208 /*
1209 * hermon_outstanding_cmdlist_init()
1210 * Context: Only called from attach() path context
1211 */
1212 int
1213 hermon_outstanding_cmdlist_init(hermon_state_t *state)
1214 {
1215 uint_t num_outstanding_cmds, head, tail;
1216 int i;
1217
1218 /*
1219 * Determine the number of the outstanding commands supported
1220 * by the Hermon device (obtained from the QUERY_FW command). Note:
1221 * Because we handle both SLEEP and NOSLEEP cases around the hermon HCR,
1222 * we know that when an interrupt comes in it will be next on the
1223 * command register, and will at most have to wait one commands time.
1224 * We do not have to reserve an outstanding command here for
1225 * interrupts.
1226 */
1227 num_outstanding_cmds = (1 << state->hs_fw.log_max_cmd);
1228
1229 /* Initialize the outstanding command list */
1230 state->hs_cmd_list.cml_list_sz = num_outstanding_cmds;
1231 state->hs_cmd_list.cml_head_indx = 0;
1232 state->hs_cmd_list.cml_tail_indx = state->hs_cmd_list.cml_list_sz - 1;
1233 state->hs_cmd_list.cml_entries_free = state->hs_cmd_list.cml_list_sz;
1234 state->hs_cmd_list.cml_waiters = 0;
1235 state->hs_cmd_list.cml_num_alloc = 0;
1236
1237 /* Allocate the memory for the outstanding command list */
1238 if (num_outstanding_cmds) {
1239 state->hs_cmd_list.cml_cmd =
1240 kmem_zalloc(state->hs_cmd_list.cml_list_sz *
1241 sizeof (hermon_cmd_t), KM_SLEEP);
1242 }
1243 mutex_init(&state->hs_cmd_list.cml_lock, NULL, MUTEX_DRIVER,
1244 DDI_INTR_PRI(state->hs_intrmsi_pri));
1245 cv_init(&state->hs_cmd_list.cml_cv, NULL, CV_DRIVER, NULL);
1246
1247 /* Initialize the individual outstanding command list entries */
1248 for (i = 0; i < state->hs_cmd_list.cml_list_sz; i++) {
1249 mutex_init(&state->hs_cmd_list.cml_cmd[i].cmd_comp_lock,
1250 NULL, MUTEX_DRIVER, DDI_INTR_PRI(state->hs_intrmsi_pri));
1251 cv_init(&state->hs_cmd_list.cml_cmd[i].cmd_comp_cv, NULL,
1252 CV_DRIVER, NULL);
1253
1254 state->hs_cmd_list.cml_cmd[i].cmd_next = i+1;
1255 state->hs_cmd_list.cml_cmd[i].cmd_prev = i-1;
1256 state->hs_cmd_list.cml_cmd[i].cmd_indx = i;
1257 state->hs_cmd_list.cml_num_alloc = i + 1;
1258 }
1259 if (num_outstanding_cmds) {
1260 head = state->hs_cmd_list.cml_head_indx;
1261 tail = state->hs_cmd_list.cml_tail_indx;
1262 state->hs_cmd_list.cml_cmd[head].cmd_prev =
1263 state->hs_cmd_list.cml_tail_indx;
1264 state->hs_cmd_list.cml_cmd[tail].cmd_next =
1265 state->hs_cmd_list.cml_head_indx;
1266 }
1267
1268 return (DDI_SUCCESS);
1269 }
1270
1271
1272 /*
1273 * hermon_outstanding_cmdlist_fini()
1274 * Context: Only called from attach() and/or detach() path contexts
1275 */
1276 void
1277 hermon_outstanding_cmdlist_fini(hermon_state_t *state)
1278 {
1279 int i;
1280
1281 /* Destroy the outstanding command list entries */
1282 for (i = 0; i < state->hs_cmd_list.cml_num_alloc; i++) {
1283 mutex_destroy(&state->hs_cmd_list.cml_cmd[i].cmd_comp_lock);
1284 cv_destroy(&state->hs_cmd_list.cml_cmd[i].cmd_comp_cv);
1285 }
1286
1287 /* Destroy the lock (and cv) and free up memory for list */
1288 mutex_destroy(&state->hs_cmd_list.cml_lock);
1289 cv_destroy(&state->hs_cmd_list.cml_cv);
1290 if (state->hs_cmd_list.cml_num_alloc) {
1291 kmem_free(state->hs_cmd_list.cml_cmd,
1292 state->hs_cmd_list.cml_list_sz * sizeof (hermon_cmd_t));
1293 }
1294 }
1295
1296
1297 /*
1298 * hermon_mbox_sync()
1299 */
1300 static void
1301 hermon_mbox_sync(hermon_mbox_t *mbox, uint_t offset, uint_t length,
1302 uint_t flag)
1303 {
1304 ddi_dma_handle_t dmahdl;
1305 int status;
1306
1307 /* Get the DMA handle from mailbox */
1308 dmahdl = mbox->mb_rsrcptr->hr_dmahdl;
1309
1310 /* Calculate offset into mailbox */
1311 status = ddi_dma_sync(dmahdl, (off_t)offset, (size_t)length, flag);
1312 if (status != DDI_SUCCESS) {
1313 return;
1314 }
1315 }
1316
1317
1318 /*
1319 * hermon_init_hca_cmd_post()
1320 * Context: Can be called from interrupt or base context.
1321 * (Currently called only from attach() path context)
1322 */
1323 int
1324 hermon_init_hca_cmd_post(hermon_state_t *state,
1325 hermon_hw_initqueryhca_t *inithca, uint_t sleepflag)
1326 {
1327 hermon_mbox_info_t mbox_info;
1328 hermon_cmd_post_t cmd;
1329 uint64_t data;
1330 uint_t size;
1331 int status, i;
1332
1333 /* Make sure we are called with the correct flag */
1334 ASSERT(sleepflag == HERMON_CMD_NOSLEEP_SPIN);
1335
1336 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
1337
1338 /* Get an "In" mailbox for the command */
1339 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX;
1340 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
1341 if (status != HERMON_CMD_SUCCESS) {
1342 return (status);
1343 }
1344
1345 /* Copy the Hermon "INIT_HCA" command into the mailbox */
1346 size = sizeof (hermon_hw_initqueryhca_t);
1347 for (i = 0; i < (size >> 3); i++) {
1348 data = ((uint64_t *)inithca)[i];
1349 ddi_put64(mbox_info.mbi_in->mb_acchdl,
1350 ((uint64_t *)mbox_info.mbi_in->mb_addr + i), data);
1351 }
1352
1353 /* Sync the mailbox for the device to read */
1354 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
1355
1356 /* Setup and post the Hermon "INIT_HCA" command */
1357 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
1358 cmd.cp_outparm = 0;
1359 cmd.cp_inmod = 0;
1360 cmd.cp_opcode = INIT_HCA;
1361 cmd.cp_opmod = 0;
1362 cmd.cp_flags = sleepflag;
1363 status = hermon_cmd_post(state, &cmd);
1364
1365 /* Free the mailbox */
1366 hermon_mbox_free(state, &mbox_info);
1367 return (status);
1368 }
1369
1370
1371 /*
1372 * hermon_close_hca_cmd_post()
1373 * Context: Can be called from interrupt or base context.
1374 * (Currently called only from attach() and/or detach() path contexts)
1375 */
1376 int
1377 hermon_close_hca_cmd_post(hermon_state_t *state, uint_t sleepflag)
1378 {
1379 hermon_cmd_post_t cmd;
1380 int status;
1381
1382 /* Make sure we are called with the correct flag */
1383 ASSERT(sleepflag == HERMON_CMD_NOSLEEP_SPIN);
1384
1385 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
1386
1387
1388 /* Setup and post the Hermon "CLOSE_HCA" command */
1389 cmd.cp_inparm = 0;
1390 cmd.cp_outparm = 0;
1391 cmd.cp_inmod = 0;
1392 cmd.cp_opcode = CLOSE_HCA;
1393 cmd.cp_opmod = 0;
1394 cmd.cp_flags = sleepflag;
1395 status = hermon_cmd_post(state, &cmd);
1396 return (status);
1397 }
1398
1399
1400 /*
1401 * hermon_set_port_cmd_post()
1402 * Context: Can be called from interrupt or base context.
1403 * (Currently called only from attach() path context)
1404 */
1405 int
1406 hermon_set_port_cmd_post(hermon_state_t *state, hermon_hw_set_port_t *initport,
1407 uint_t port, uint_t sleepflag)
1408 {
1409 hermon_mbox_info_t mbox_info;
1410 hermon_cmd_post_t cmd;
1411 uint64_t data;
1412 uint_t size;
1413 int status, i;
1414
1415 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
1416
1417 /* Get an "In" mailbox for the command */
1418 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX;
1419 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
1420 if (status != HERMON_CMD_SUCCESS) {
1421 return (status);
1422 }
1423
1424 /* Copy the Hermon "INIT_PORT" command into the mailbox */
1425 size = sizeof (hermon_hw_set_port_t);
1426 for (i = 0; i < (size >> 3); i++) {
1427 data = ((uint64_t *)initport)[i];
1428 ddi_put64(mbox_info.mbi_in->mb_acchdl,
1429 ((uint64_t *)mbox_info.mbi_in->mb_addr + i), data);
1430 }
1431
1432 /* Sync the mailbox for the device to read */
1433 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
1434
1435 /* Setup and post the Hermon "SET_PORT" command */
1436 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
1437 cmd.cp_outparm = 0;
1438 cmd.cp_inmod = port;
1439 cmd.cp_opcode = SET_PORT;
1440 cmd.cp_opmod = 0;
1441 cmd.cp_flags = sleepflag;
1442 status = hermon_cmd_post(state, &cmd);
1443
1444 /* Free the mailbox */
1445 hermon_mbox_free(state, &mbox_info);
1446 return (status);
1447 }
1448
1449
1450 /*
1451 * hermon_init_port_cmd_post()
1452 * Context: Can be called from interrupt or base context.
1453 * (Currently called only from attach() and/or detach() path contexts)
1454 */
1455 int
1456 hermon_init_port_cmd_post(hermon_state_t *state, uint_t port, uint_t sleepflag)
1457 {
1458 hermon_cmd_post_t cmd;
1459 int status;
1460
1461 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
1462
1463 /* Setup and post the Hermon "INIT_PORT" command */
1464 cmd.cp_inparm = 0;
1465 cmd.cp_outparm = 0;
1466 cmd.cp_inmod = port;
1467 cmd.cp_opcode = INIT_PORT;
1468 cmd.cp_opmod = 0;
1469 cmd.cp_flags = sleepflag;
1470 status = hermon_cmd_post(state, &cmd);
1471
1472 return (status);
1473 }
1474
1475
1476 /*
1477 * hermon_close_port_cmd_post()
1478 * Context: Can be called from interrupt or base context.
1479 * (Currently called only from attach() and/or detach() path contexts)
1480 */
1481 int
1482 hermon_close_port_cmd_post(hermon_state_t *state, uint_t port, uint_t sleepflag)
1483 {
1484 hermon_cmd_post_t cmd;
1485 int status;
1486
1487 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
1488
1489 /* Setup and post the Hermon "CLOSE_PORT" command */
1490 cmd.cp_inparm = 0;
1491 cmd.cp_outparm = 0;
1492 cmd.cp_inmod = port;
1493 cmd.cp_opcode = CLOSE_PORT;
1494 cmd.cp_opmod = 0;
1495 cmd.cp_flags = sleepflag;
1496 status = hermon_cmd_post(state, &cmd);
1497 return (status);
1498 }
1499
1500
1501 /*
1502 * hermon_mod_stat_cfg_cmd_post()
1503 * Context: Can be called only from attach() path
1504 *
1505 * This routine was initially implemented to enable SRQ. That's no longer needed
1506 * in hermon, and the code is conditionally compiled OUT, but left here because
1507 * there are other static configuration parameters we might one day want to set
1508 */
1509 #ifdef HERMON_NO_MOD_STAT_CFG
1510 int
1511 hermon_mod_stat_cfg_cmd_post(hermon_state_t *state)
1512 {
1513 hermon_mbox_info_t mbox_info;
1514 hermon_cmd_post_t cmd;
1515 hermon_hw_mod_stat_cfg_t *mod;
1516 hermon_hw_msg_in_mod_t inmod;
1517 uint64_t data;
1518 uint_t size;
1519 int status, i;
1520
1521 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
1522
1523 /*
1524 * "MOD_STAT_CFG" needs an INMBOX parameter, to specify what operations
1525 * to do. However, at the point in time that we call this command, the
1526 * DDR has not yet been initialized, and all INMBOX'es are located in
1527 * DDR. Because we want to call MOD_STAT_CFG before QUERY_DEVLIM is
1528 * called, and thus call it before DDR is setup, we simply use an
1529 * OUTMBOX memory location here as our INMBOX parameter.
1530 */
1531 mbox_info.mbi_alloc_flags = HERMON_ALLOC_OUTMBOX;
1532 status = hermon_mbox_alloc(state, &mbox_info, HERMON_NOSLEEP);
1533 if (status != HERMON_CMD_SUCCESS) {
1534 return (status);
1535 }
1536
1537 /*
1538 * Allocate on the heap our 'mod_stat_cfg' structure. We want to
1539 * ideally move all of this on to the stack in the future, but this
1540 * works well for now.
1541 */
1542 mod = (hermon_hw_mod_stat_cfg_t *)kmem_zalloc(
1543 sizeof (hermon_hw_mod_stat_cfg_t), KM_SLEEP);
1544
1545 /* Setup "MOD_STAT_CFG" settings */
1546 mod->srq_m = 1;
1547 mod->srq = state->hs_cfg_profile->cp_srq_enable;
1548
1549 if (mod->srq) {
1550 /* use DEV_LIMS num srq */
1551 mod->log_max_srq = state->hs_cfg_profile->cp_log_num_srq;
1552 } else {
1553 mod->log_max_srq = 0;
1554 }
1555
1556 /* Copy the "MOD_STAT_CFG" command into the "In" mailbox */
1557 size = sizeof (hermon_hw_mod_stat_cfg_t);
1558 for (i = 0; i < (size >> 3); i++) {
1559 data = ((uint64_t *)mod)[i];
1560 ddi_put64(mbox_info.mbi_in->mb_acchdl,
1561 ((uint64_t *)mbox_info.mbi_in->mb_addr + i), data);
1562 }
1563
1564 /* Sync the mailbox for the device to read */
1565 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
1566
1567 /* Setup and post the Hermon "MOD_STAT_CFG" command */
1568 cmd.cp_inparm = mbox_info.mbi_out->mb_mapaddr;
1569 cmd.cp_outparm = 0;
1570 cmd.cp_inmod = 0;
1571 cmd.cp_opcode = MOD_STAT_CFG;
1572 cmd.cp_opmod = HERMON_MOD_STAT_CFG_PTR;
1573 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN;
1574 status = hermon_cmd_post(state, &cmd);
1575
1576 /* Free "MOD_STAT_CFG" struct */
1577 kmem_free(mod, sizeof (hermon_hw_mod_stat_cfg_t));
1578
1579 /* Free the mailbox */
1580 hermon_mbox_free(state, &mbox_info);
1581 return (status);
1582 }
1583 #endif
1584
1585
1586 /*
1587 * hermon_map_cmd_post()
1588 * Context: Can be called only from user or kernel context
1589 *
1590 * Generic routine to map FW, ICMA, and ICM.
1591 */
1592 int
1593 hermon_map_cmd_post(hermon_state_t *state, hermon_dma_info_t *dma,
1594 uint16_t opcode, ddi_dma_cookie_t cookie, uint_t ccount)
1595 {
1596 hermon_mbox_info_t mbox_info;
1597 hermon_cmd_post_t cmd;
1598 hermon_hw_vpm_t vpm;
1599 uint64_t data;
1600 uint64_t paddr, vaddr;
1601 uint_t size;
1602 int status, i, j, k = 0;
1603 int max_mailbox_size;
1604 int cookie_num_icm_pages;
1605 int num_vpm_entries;
1606 int log2_npages;
1607 int npages;
1608
1609 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
1610
1611 /* Allocate an IN mailbox */
1612 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX;
1613 status = hermon_mbox_alloc(state, &mbox_info, HERMON_SLEEP);
1614 if (status != HERMON_CMD_SUCCESS) {
1615 return (status);
1616 }
1617
1618 /* Initialize cmd parameters */
1619 cmd.cp_outparm = 0;
1620 cmd.cp_opcode = opcode;
1621 cmd.cp_opmod = 0;
1622 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN;
1623
1624 /*
1625 * Allocate a list of VPM (Virtual Physical Mapping) structures.
1626 * A VPM encodes a power-of-2 number of DMA pages that have been
1627 * allocated and are passed in the dma_info. We need to break up
1628 * the DMA cookies that are in the dma_info into power-of-2 page
1629 * mappings. We also need to keep track of the number of VPMs we
1630 * have total, as it is used as the inmod for this command.
1631 */
1632
1633 /* Start with the ICM address passed and the first cookie */
1634 vaddr = dma->icmaddr;
1635
1636 /* Initialize the VPM count and the VPM struct */
1637 num_vpm_entries = 0;
1638 size = sizeof (hermon_hw_vpm_t);
1639 bzero(&vpm, size);
1640
1641 /*
1642 * Establish a max mailbox size (in VPM entries). If we reach this,
1643 * we must post a MAP command, reinitialzie num_vpm_entries, and
1644 * continue.
1645 */
1646 max_mailbox_size = HERMON_MBOX_SIZE / size;
1647
1648 /*
1649 * First, walk through the DMA cookies and build VPMs from them.
1650 */
1651 while (ccount-- > 0) {
1652
1653 /* Determine the number of ICM pages in this cookie. */
1654 cookie_num_icm_pages = cookie.dmac_size / HERMON_PAGESIZE;
1655
1656 /* Initialize this set of VPM's starting physical address. */
1657 paddr = cookie.dmac_laddress;
1658
1659 /*
1660 * Now build a set of VPMs for this cookie's memory, breaking
1661 * up the cookies into multiple VPMs if necessary to achieve
1662 * the required power-of-2 number of pages per VPM. Once each
1663 * VPM is constructed, write it out to the mailbox memory.
1664 */
1665 for (i = cookie_num_icm_pages; i > 0; i -= npages) {
1666 log2_npages = highbit(i) - 1;
1667 npages = (1 << log2_npages);
1668 /* Ensure this chunk is aligned on it's own size */
1669 while (((npages * HERMON_PAGESIZE - 1) & paddr) != 0) {
1670 log2_npages--;
1671 npages = (1 << log2_npages);
1672 }
1673 vpm.log2sz = log2_npages;
1674
1675 vpm.paddr_l = (uint32_t)(paddr >> 12);
1676 vpm.paddr_h = (uint32_t)(paddr >> 32);
1677 /* Increment the paddr for the next VPM */
1678 paddr += npages * HERMON_PAGESIZE;
1679
1680 if (opcode == MAP_ICM) {
1681 vpm.vaddr_l = (uint32_t)(vaddr >> 12);
1682 vpm.vaddr_h = (uint32_t)(vaddr >> 32);
1683 /* Increment the ICM address for the next VPM */
1684 vaddr += npages * HERMON_PAGESIZE;
1685 }
1686
1687 /*
1688 * Copy this VPM into the "In" mailbox. Note we're
1689 * using 'k' as the offset from mb_addr for this cmd.
1690 */
1691 for (j = 0; j < (size >> 3); j++, k++) {
1692 data = ((uint64_t *)(void *)&vpm)[j];
1693 ddi_put64(mbox_info.mbi_in->mb_acchdl,
1694 ((uint64_t *)mbox_info.mbi_in->mb_addr + k),
1695 data);
1696 }
1697
1698 /*
1699 * Increment the number of VPM entries and check
1700 * against max mailbox size. If we have reached
1701 * the maximum mailbox size, post the map cmd.
1702 */
1703 if (++num_vpm_entries == max_mailbox_size) {
1704
1705 /* Sync the mailbox for the device to read */
1706 hermon_mbox_sync(mbox_info.mbi_in, 0, (size *
1707 num_vpm_entries), DDI_DMA_SYNC_FORDEV);
1708
1709 /* Setup and post the command */
1710 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
1711 cmd.cp_inmod = num_vpm_entries;
1712 status = hermon_cmd_post(state, &cmd);
1713 if (status != HERMON_CMD_SUCCESS) {
1714 cmn_err(CE_NOTE, "hermon%d: %s cmd "
1715 "failed (0x%x)", state->hs_instance,
1716 opcode == MAP_FA ? "MAP_FA" :
1717 opcode == MAP_ICM ? "MAP_ICM" :
1718 opcode == MAP_ICM_AUX ? "MAP_ICMA" :
1719 "UNKNOWN", status);
1720 goto map_fail;
1721 }
1722
1723 /*
1724 * Reinitialize num_vpm_entries, and the
1725 * mb_addr offset
1726 */
1727 num_vpm_entries = k = 0;
1728 }
1729 }
1730
1731 /* If count remains, move onto the next cookie */
1732 if (ccount != 0) {
1733 ddi_dma_nextcookie(dma->dma_hdl, &cookie);
1734 }
1735 }
1736
1737 if (num_vpm_entries) {
1738
1739 /* Sync the mailbox for the device to read */
1740 hermon_mbox_sync(mbox_info.mbi_in, 0, (size * num_vpm_entries),
1741 DDI_DMA_SYNC_FORDEV);
1742
1743 /* Setup and post the command */
1744 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
1745 cmd.cp_inmod = num_vpm_entries;
1746 status = hermon_cmd_post(state, &cmd);
1747 if (status != HERMON_CMD_SUCCESS) {
1748 cmn_err(CE_NOTE, "hermon%d: %s cmd "
1749 "failed (0x%x)", state->hs_instance,
1750 opcode == MAP_FA ? "MAP_FA" :
1751 opcode == MAP_ICM ? "MAP_ICM" :
1752 opcode == MAP_ICM_AUX ? "MAP_ICMA" :
1753 "UNKNOWN", status);
1754 goto map_fail;
1755 }
1756 }
1757
1758 map_fail:
1759 /* Free the mailbox */
1760 hermon_mbox_free(state, &mbox_info);
1761 return (status);
1762 }
1763
1764
1765 /*
1766 * hermon_unmap_fa_cmd_post()
1767 * Context: Can be called only from attach() path
1768 */
1769 int
1770 hermon_unmap_fa_cmd_post(hermon_state_t *state)
1771 {
1772 hermon_cmd_post_t cmd;
1773 int status;
1774
1775 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
1776
1777 /* Setup and post the Hermon "UNMAP_FA" command */
1778 cmd.cp_inparm = 0;
1779 cmd.cp_outparm = 0;
1780 cmd.cp_inmod = 0;
1781 cmd.cp_opcode = UNMAP_FA;
1782 cmd.cp_opmod = 0;
1783 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN;
1784 status = hermon_cmd_post(state, &cmd);
1785
1786 return (status);
1787 }
1788
1789
1790 /*
1791 * hermon_run_fw_cmd_post()
1792 * Context: Can be called only from attach() path
1793 */
1794 int
1795 hermon_run_fw_cmd_post(hermon_state_t *state)
1796 {
1797 hermon_cmd_post_t cmd;
1798 int status;
1799
1800 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
1801
1802 /* Setup and post the Hermon "RUN_FW" command */
1803 cmd.cp_inparm = 0;
1804 cmd.cp_outparm = 0;
1805 cmd.cp_inmod = 0;
1806 cmd.cp_opcode = RUN_FW;
1807 cmd.cp_opmod = 0;
1808 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN;
1809
1810 status = hermon_cmd_post(state, &cmd);
1811 #ifdef FMA_TEST
1812 if (hermon_test_num == -2) {
1813 status = HERMON_CMD_BAD_NVMEM;
1814 /*
1815 * No need of an ereport here since this case
1816 * is treated as a degradation later.
1817 */
1818 HERMON_FMANOTE(state, HERMON_FMA_BADNVMEM);
1819 }
1820 #endif
1821 return (status);
1822 }
1823
1824
1825 /*
1826 * hermon_set_icm_size_cmd_post()
1827 * Context: Can be called only from attach() path
1828 */
1829 int
1830 hermon_set_icm_size_cmd_post(hermon_state_t *state)
1831 {
1832 hermon_cmd_post_t cmd;
1833 int status;
1834
1835 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
1836
1837 /* Setup and post the Hermon "SET_ICM_SIZE" command */
1838 cmd.cp_inparm = (uint64_t)state->hs_icm_sz;
1839 cmd.cp_outparm = 0;
1840 cmd.cp_inmod = 0;
1841 cmd.cp_opcode = SET_ICM_SIZE;
1842 cmd.cp_opmod = 0;
1843 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN;
1844 status = hermon_cmd_post(state, &cmd);
1845
1846 /*
1847 * Aux ICM size in 4K pages returned in output param
1848 * convert it to bytes
1849 */
1850 state->hs_icma_sz = (uint64_t)(cmd.cp_outparm << HERMON_PAGESHIFT);
1851 return (status);
1852 }
1853
1854
1855 /*
1856 * hermon_unmap_icm_aux_cmd_post()
1857 * Context: Can be called only from attach() path
1858 */
1859 int
1860 hermon_unmap_icm_aux_cmd_post(hermon_state_t *state)
1861 {
1862 hermon_cmd_post_t cmd;
1863 int status;
1864
1865 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
1866
1867 /* Setup and post the Hermon "UNMAP_ICM_AUX" command */
1868 cmd.cp_inparm = 0;
1869 cmd.cp_outparm = 0;
1870 cmd.cp_inmod = 0;
1871 cmd.cp_opcode = UNMAP_ICM_AUX;
1872 cmd.cp_opmod = 0;
1873 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN;
1874 status = hermon_cmd_post(state, &cmd);
1875 return (status);
1876 }
1877
1878
1879 /*
1880 * hermon_unmap_icm_cmd_post()
1881 * Context: Can be called from base or attach context
1882 */
1883 int
1884 hermon_unmap_icm_cmd_post(hermon_state_t *state, hermon_dma_info_t *dma_info)
1885 {
1886 hermon_cmd_post_t cmd;
1887 uint64_t addr;
1888 uint32_t npages;
1889 int status;
1890
1891 /*
1892 * Setup and post the Hermon "UNMAP_ICM" command. If a
1893 * hermon_dma_info_t was passed, we want to unmap a set
1894 * of pages. Otherwise, unmap all of ICM.
1895 */
1896 if (dma_info != NULL) {
1897 addr = dma_info->icmaddr;
1898 npages = dma_info->length / HERMON_PAGESIZE;
1899 } else {
1900 addr = 0;
1901 npages = state->hs_icm_sz / HERMON_PAGESIZE;
1902 }
1903
1904 /* Setup and post the Hermon "UNMAP_ICM" command */
1905 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
1906 cmd.cp_inparm = addr;
1907 cmd.cp_outparm = 0;
1908 cmd.cp_inmod = npages;
1909 cmd.cp_opcode = UNMAP_ICM;
1910 cmd.cp_opmod = 0;
1911 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN;
1912 status = hermon_cmd_post(state, &cmd);
1913 return (status);
1914 }
1915
1916
1917 /*
1918 * hermon_mad_ifc_cmd_post()
1919 * Context: Can be called from interrupt or base context.
1920 */
1921 int
1922 hermon_mad_ifc_cmd_post(hermon_state_t *state, uint_t port,
1923 uint_t sleepflag, uint32_t *mad, uint32_t *resp)
1924 {
1925 hermon_mbox_info_t mbox_info;
1926 hermon_cmd_post_t cmd;
1927 uint_t size;
1928 int status;
1929
1930 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
1931
1932 /* Get "In" and "Out" mailboxes for the command */
1933 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX | HERMON_ALLOC_OUTMBOX;
1934 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
1935 if (status != HERMON_CMD_SUCCESS) {
1936 return (status);
1937 }
1938
1939 /* Copy the request MAD into the "In" mailbox */
1940 size = HERMON_CMD_MAD_IFC_SIZE;
1941 bcopy(mad, mbox_info.mbi_in->mb_addr, size);
1942
1943 /* Sync the mailbox for the device to read */
1944 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
1945
1946 /* Setup the Hermon "MAD_IFC" command */
1947 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
1948 cmd.cp_outparm = mbox_info.mbi_out->mb_mapaddr;
1949 cmd.cp_inmod = port;
1950 cmd.cp_opcode = MAD_IFC;
1951 cmd.cp_opmod = HERMON_CMD_MKEY_CHECK; /* Enable MKey checking */
1952 cmd.cp_flags = sleepflag;
1953 status = hermon_cmd_post(state, &cmd);
1954 if (status != HERMON_CMD_SUCCESS) {
1955 goto mad_ifc_fail;
1956 }
1957
1958 /* Sync the mailbox to read the results */
1959 hermon_mbox_sync(mbox_info.mbi_out, 0, size, DDI_DMA_SYNC_FORCPU);
1960
1961 /* Copy the response MAD into "resp" */
1962 bcopy(mbox_info.mbi_out->mb_addr, resp, size);
1963
1964 mad_ifc_fail:
1965 /* Free the mailbox */
1966 hermon_mbox_free(state, &mbox_info);
1967 return (status);
1968 }
1969
1970
1971 /*
1972 * hermon_getportinfo_cmd_post()
1973 * Context: Can be called from interrupt or base context.
1974 */
1975 int
1976 hermon_getportinfo_cmd_post(hermon_state_t *state, uint_t port,
1977 uint_t sleepflag, sm_portinfo_t *portinfo)
1978 {
1979 hermon_mbox_info_t mbox_info;
1980 hermon_cmd_post_t cmd;
1981 uint32_t *mbox;
1982 uint_t size;
1983 int status, i;
1984
1985 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
1986
1987 /* Get "In" and "Out" mailboxes for the command */
1988 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX | HERMON_ALLOC_OUTMBOX;
1989 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
1990 if (status != HERMON_CMD_SUCCESS) {
1991 return (status);
1992 }
1993
1994 /* Build the GetPortInfo request MAD in the "In" mailbox */
1995 size = HERMON_CMD_MAD_IFC_SIZE;
1996 mbox = (uint32_t *)mbox_info.mbi_in->mb_addr;
1997 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[0], HERMON_CMD_MADHDR0);
1998 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[1], HERMON_CMD_MADHDR1);
1999 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[2], HERMON_CMD_MADHDR2);
2000 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[3], HERMON_CMD_MADHDR3);
2001 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[4], HERMON_CMD_PORTINFO);
2002 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[5], port);
2003 for (i = 6; i < (size >> 2); i++) {
2004 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[i], 0);
2005 }
2006
2007 /* Sync the mailbox for the device to read */
2008 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
2009
2010 /* Setup the Hermon "MAD_IFC" command */
2011 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
2012 cmd.cp_outparm = mbox_info.mbi_out->mb_mapaddr;
2013 cmd.cp_inmod = port;
2014 cmd.cp_opcode = MAD_IFC;
2015 cmd.cp_opmod = HERMON_CMD_MKEY_DONTCHECK; /* No MKey checking */
2016 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN; /* NO SLEEP */
2017 status = hermon_cmd_post(state, &cmd);
2018 if (status != HERMON_CMD_SUCCESS) {
2019 goto getportinfo_fail;
2020 }
2021
2022 /* Sync the mailbox to read the results */
2023 size = sizeof (sm_portinfo_t);
2024 hermon_mbox_sync(mbox_info.mbi_out, HERMON_CMD_MADDATA_OFFSET,
2025 size, DDI_DMA_SYNC_FORCPU);
2026
2027 /*
2028 * Copy GetPortInfo response MAD into "portinfo". Do any endian
2029 * swapping that may be necessary to flip any of the "portinfo"
2030 * fields
2031 */
2032 bcopy((void *)((uintptr_t)mbox_info.mbi_out->mb_addr +
2033 HERMON_CMD_MADDATA_OFFSET), portinfo, size);
2034 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*portinfo))
2035 HERMON_GETPORTINFO_SWAP(portinfo);
2036
2037 getportinfo_fail:
2038 /* Free the mailbox */
2039 hermon_mbox_free(state, &mbox_info);
2040 return (status);
2041 }
2042
2043 /*
2044 * hermon_is_ext_port_counters_supported()
2045 *
2046 * Determine weather extended port counters are supported or not by sending
2047 * ClassPortInfo perf mgmt class MAD.
2048 */
2049 int
2050 hermon_is_ext_port_counters_supported(hermon_state_t *state, uint_t port,
2051 uint_t sleepflag, int *ext_width_supported)
2052 {
2053 hermon_mbox_info_t mbox_info;
2054 hermon_cmd_post_t cmd;
2055 uint64_t data;
2056 uint32_t *mbox;
2057 int status;
2058
2059 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
2060
2061 /* Get "In" and "Out" mailboxes for the command */
2062 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX | HERMON_ALLOC_OUTMBOX;
2063 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
2064 if (status != HERMON_CMD_SUCCESS) {
2065 return (status);
2066 }
2067
2068 /* Build the ClassPortInfo request MAD in the "In" mailbox */
2069 mbox = (uint32_t *)mbox_info.mbi_in->mb_addr;
2070
2071 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[0], HERMON_CMD_PERF_GET);
2072 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[1], HERMON_CMD_MADHDR1);
2073 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[2], HERMON_CMD_MADHDR2);
2074 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[3], HERMON_CMD_MADHDR3);
2075 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[4],
2076 HERMON_CMD_CLASSPORTINFO);
2077 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[5], HERMON_CMD_PERFATTR);
2078
2079 /* Sync the mailbox for the device to read */
2080 hermon_mbox_sync(mbox_info.mbi_in, 0, HERMON_CMD_MAD_IFC_SIZE,
2081 DDI_DMA_SYNC_FORDEV);
2082
2083 /* Setup the Hermon "MAD_IFC" command */
2084 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
2085 cmd.cp_outparm = mbox_info.mbi_out->mb_mapaddr;
2086 cmd.cp_inmod = port;
2087 cmd.cp_opcode = MAD_IFC;
2088 /* No MKey and BKey checking */
2089 cmd.cp_opmod = HERMON_CMD_MKEY_DONTCHECK | HERMON_CMD_BKEY_DONTCHECK;
2090 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN; /* NO SLEEP */
2091 status = hermon_cmd_post(state, &cmd);
2092 if (status != HERMON_CMD_SUCCESS) {
2093 goto fail;
2094 }
2095
2096 /* Sync the mailbox to read the results */
2097 hermon_mbox_sync(mbox_info.mbi_out, 0, HERMON_CMD_MAD_IFC_SIZE,
2098 DDI_DMA_SYNC_FORCPU);
2099
2100 /*
2101 * We can discard the MAD header and the reserved area of the
2102 * perf mgmt class MAD
2103 */
2104 data = ddi_get64(mbox_info.mbi_out->mb_acchdl,
2105 ((uint64_t *)mbox_info.mbi_out->mb_addr + 8));
2106 *ext_width_supported = (data & (HERMON_IS_EXT_WIDTH_SUPPORTED |
2107 HERMON_IS_EXT_WIDTH_SUPPORTED_NOIETF)) ? 1 : 0;
2108
2109 fail:
2110 /* Free the mailbox */
2111 hermon_mbox_free(state, &mbox_info);
2112 return (status);
2113 }
2114
2115 /*
2116 * hermon_getextpefcntr_cmd_post()
2117 *
2118 * Read the extended performance counters of the specified port and
2119 * copy them into perfinfo.
2120 */
2121 int
2122 hermon_getextperfcntr_cmd_post(hermon_state_t *state, uint_t port,
2123 uint_t sleepflag, hermon_hw_sm_extperfcntr_t *perfinfo)
2124 {
2125 hermon_mbox_info_t mbox_info;
2126 hermon_cmd_post_t cmd;
2127 uint64_t data;
2128 uint32_t *mbox;
2129 int status, i;
2130
2131 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
2132
2133 /* Get "In" and "Out" mailboxes for the command */
2134 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX | HERMON_ALLOC_OUTMBOX;
2135 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
2136 if (status != HERMON_CMD_SUCCESS) {
2137 return (status);
2138 }
2139
2140 /* Build PortCountersExtended request MAD in the "In" mailbox */
2141 mbox = (uint32_t *)mbox_info.mbi_in->mb_addr;
2142
2143 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[0], HERMON_CMD_PERF_GET);
2144 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[1], HERMON_CMD_MADHDR1);
2145 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[2], HERMON_CMD_MADHDR2);
2146 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[3], HERMON_CMD_MADHDR3);
2147 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[4],
2148 HERMON_CMD_EXTPERFCNTRS);
2149 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[5], HERMON_CMD_PERFATTR);
2150 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[16], (port << 16));
2151
2152 /* Sync the mailbox for the device to read */
2153 hermon_mbox_sync(mbox_info.mbi_in, 0, HERMON_CMD_MAD_IFC_SIZE,
2154 DDI_DMA_SYNC_FORDEV);
2155
2156 /* Setup the Hermon "MAD_IFC" command */
2157 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
2158 cmd.cp_outparm = mbox_info.mbi_out->mb_mapaddr;
2159 cmd.cp_inmod = port;
2160 cmd.cp_opcode = MAD_IFC;
2161 /* No MKey and BKey checking */
2162 cmd.cp_opmod = HERMON_CMD_MKEY_DONTCHECK | HERMON_CMD_BKEY_DONTCHECK;
2163 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN; /* NO SLEEP */
2164 status = hermon_cmd_post(state, &cmd);
2165 if (status != HERMON_CMD_SUCCESS) {
2166 goto fail;
2167 }
2168
2169 /* Sync the mailbox to read the results */
2170 hermon_mbox_sync(mbox_info.mbi_out, 0, HERMON_CMD_MAD_IFC_SIZE,
2171 DDI_DMA_SYNC_FORCPU);
2172
2173 /*
2174 * Copy Perfcounters into "perfinfo". We can discard the MAD
2175 * header and the reserved area of the perf mgmt class MAD.
2176 */
2177 for (i = 0; i < (sizeof (hermon_hw_sm_extperfcntr_t) >> 3); i++) {
2178 data = ddi_get64(mbox_info.mbi_out->mb_acchdl,
2179 ((uint64_t *)mbox_info.mbi_out->mb_addr + i + 8));
2180 ((uint64_t *)(void *)perfinfo)[i] = data;
2181 }
2182
2183 fail:
2184 /* Free the mailbox */
2185 hermon_mbox_free(state, &mbox_info);
2186 return (status);
2187 }
2188
2189 /*
2190 * hermon_getpefcntr_cmd_post()
2191 * Context: Can be called from interrupt or base context.
2192 *
2193 * If reset is zero, read the performance counters of the specified port and
2194 * copy them into perfinfo.
2195 * If reset is non-zero reset the performance counters of the specified port.
2196 */
2197 int
2198 hermon_getperfcntr_cmd_post(hermon_state_t *state, uint_t port,
2199 uint_t sleepflag, hermon_hw_sm_perfcntr_t *perfinfo, int reset)
2200 {
2201 hermon_mbox_info_t mbox_info;
2202 hermon_cmd_post_t cmd;
2203 uint64_t data;
2204 uint32_t *mbox;
2205 uint_t size;
2206 int status, i;
2207
2208 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
2209
2210 /* Get "In" and "Out" mailboxes for the command */
2211 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX | HERMON_ALLOC_OUTMBOX;
2212 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
2213 if (status != HERMON_CMD_SUCCESS) {
2214 return (status);
2215 }
2216
2217 /* Build the GetPortInfo request MAD in the "In" mailbox */
2218 size = HERMON_CMD_MAD_IFC_SIZE;
2219 mbox = (uint32_t *)mbox_info.mbi_in->mb_addr;
2220
2221 if (reset) {
2222 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[0],
2223 HERMON_CMD_PERF_SET);
2224 } else {
2225 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[0],
2226 HERMON_CMD_PERF_GET);
2227 }
2228 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[1], HERMON_CMD_MADHDR1);
2229 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[2], HERMON_CMD_MADHDR2);
2230 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[3], HERMON_CMD_MADHDR3);
2231 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[4], HERMON_CMD_PERFCNTRS);
2232 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[5], HERMON_CMD_PERFATTR);
2233
2234 if (reset) {
2235 /* reset counters for XmitData, RcvData, XmitPkts, RcvPkts */
2236 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[16],
2237 ((port << 16) | 0xf000));
2238
2239 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[22], 0);
2240 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[23], 0);
2241 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[24], 0);
2242 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[25], 0);
2243 } else
2244 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[16], (port << 16));
2245
2246 /* Sync the mailbox for the device to read */
2247 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
2248
2249 /* Setup the Hermon "MAD_IFC" command */
2250 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
2251 cmd.cp_outparm = mbox_info.mbi_out->mb_mapaddr;
2252 cmd.cp_inmod = port;
2253 cmd.cp_opcode = MAD_IFC;
2254 /* No MKey and BKey checking */
2255 cmd.cp_opmod = HERMON_CMD_MKEY_DONTCHECK | HERMON_CMD_BKEY_DONTCHECK;
2256 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN; /* NO SLEEP */
2257 status = hermon_cmd_post(state, &cmd);
2258 if (status != HERMON_CMD_SUCCESS) {
2259 goto getperfinfo_fail;
2260 }
2261
2262 /* Sync the mailbox to read the results */
2263 size = HERMON_CMD_MAD_IFC_SIZE;
2264 hermon_mbox_sync(mbox_info.mbi_out, 0, size, DDI_DMA_SYNC_FORCPU);
2265
2266 if (reset == 0) {
2267 size = sizeof (hermon_hw_sm_perfcntr_t); /* for the copy */
2268 /*
2269 * Copy Perfcounters into "perfinfo". We can discard the MAD
2270 * header and the 8 Quadword reserved area of the PERM mgmt
2271 * class MAD
2272 */
2273
2274 for (i = 0; i < size >> 3; i++) {
2275 data = ddi_get64(mbox_info.mbi_out->mb_acchdl,
2276 ((uint64_t *)mbox_info.mbi_out->mb_addr + i + 8));
2277 ((uint64_t *)(void *)perfinfo)[i] = data;
2278 }
2279 }
2280
2281 getperfinfo_fail:
2282 /* Free the mailbox */
2283 hermon_mbox_free(state, &mbox_info);
2284 return (status);
2285 }
2286
2287
2288
2289 /*
2290 * hermon_getnodeinfo_cmd_post()
2291 * Context: Can be called from interrupt or base context.
2292 * (Currently called only from attach() and detach() path contexts)
2293 */
2294 int
2295 hermon_getnodeinfo_cmd_post(hermon_state_t *state, uint_t sleepflag,
2296 sm_nodeinfo_t *nodeinfo)
2297 {
2298 hermon_mbox_info_t mbox_info;
2299 hermon_cmd_post_t cmd;
2300 uint32_t *mbox;
2301 uint_t size;
2302 int status, i;
2303
2304 /* Make sure we are called with the correct flag */
2305 ASSERT(sleepflag == HERMON_CMD_NOSLEEP_SPIN);
2306
2307 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
2308
2309 /* Get "In" and "Out" mailboxes for the command */
2310 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX | HERMON_ALLOC_OUTMBOX;
2311 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
2312 if (status != HERMON_CMD_SUCCESS) {
2313 return (status);
2314 }
2315
2316 /* Build the GetNodeInfo request MAD into the "In" mailbox */
2317 size = HERMON_CMD_MAD_IFC_SIZE;
2318 mbox = (uint32_t *)mbox_info.mbi_in->mb_addr;
2319 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[0], HERMON_CMD_MADHDR0);
2320 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[1], HERMON_CMD_MADHDR1);
2321 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[2], HERMON_CMD_MADHDR2);
2322 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[3], HERMON_CMD_MADHDR3);
2323 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[4], HERMON_CMD_NODEINFO);
2324 for (i = 5; i < (size >> 2); i++) {
2325 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[i], 0);
2326 }
2327
2328 /* Sync the mailbox for the device to read */
2329 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
2330
2331 /* Setup the Hermon "MAD_IFC" command */
2332 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
2333 cmd.cp_outparm = mbox_info.mbi_out->mb_mapaddr;
2334 cmd.cp_inmod = 1; /* Get NodeInfo from port #1 */
2335 cmd.cp_opcode = MAD_IFC;
2336 cmd.cp_opmod = HERMON_CMD_MKEY_DONTCHECK; /* No MKey checking */
2337 cmd.cp_flags = sleepflag;
2338 status = hermon_cmd_post(state, &cmd);
2339 if (status != HERMON_CMD_SUCCESS) {
2340 goto getnodeinfo_fail;
2341 }
2342
2343 /* Sync the mailbox to read the results */
2344 size = sizeof (sm_nodeinfo_t);
2345 hermon_mbox_sync(mbox_info.mbi_out, HERMON_CMD_MADDATA_OFFSET,
2346 size, DDI_DMA_SYNC_FORCPU);
2347
2348 /*
2349 * Copy GetNodeInfo response MAD into "nodeinfo". Do any endian
2350 * swapping that may be necessary to flip any of the "nodeinfo"
2351 * fields
2352 */
2353 bcopy((void *)((uintptr_t)mbox_info.mbi_out->mb_addr +
2354 HERMON_CMD_MADDATA_OFFSET), nodeinfo, size);
2355 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*nodeinfo))
2356 HERMON_GETNODEINFO_SWAP(nodeinfo);
2357
2358 getnodeinfo_fail:
2359 /* Free the mailbox */
2360 hermon_mbox_free(state, &mbox_info);
2361 return (status);
2362 }
2363
2364
2365 /*
2366 * hermon_getnodedesc_cmd_post()
2367 * Context: Can be called from interrupt or base context.
2368 * (Currently called only from attach() and detach() path contexts)
2369 */
2370 int
2371 hermon_getnodedesc_cmd_post(hermon_state_t *state, uint_t sleepflag,
2372 sm_nodedesc_t *nodedesc)
2373 {
2374 hermon_mbox_info_t mbox_info;
2375 hermon_cmd_post_t cmd;
2376 uint32_t *mbox;
2377 uint_t size;
2378 int status, i;
2379
2380 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
2381
2382 /* Get "In" and "Out" mailboxes for the command */
2383 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX | HERMON_ALLOC_OUTMBOX;
2384 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
2385 if (status != HERMON_CMD_SUCCESS) {
2386 return (status);
2387 }
2388
2389 /* Build the GetNodeDesc request MAD into the "In" mailbox */
2390 size = HERMON_CMD_MAD_IFC_SIZE;
2391 mbox = (uint32_t *)mbox_info.mbi_in->mb_addr;
2392 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[0], HERMON_CMD_MADHDR0);
2393 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[1], HERMON_CMD_MADHDR1);
2394 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[2], HERMON_CMD_MADHDR2);
2395 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[3], HERMON_CMD_MADHDR3);
2396 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[4], HERMON_CMD_NODEDESC);
2397 for (i = 5; i < (size >> 2); i++) {
2398 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[i], 0);
2399 }
2400
2401 /* Sync the mailbox for the device to read */
2402 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
2403
2404 /* Setup the Hermon "MAD_IFC" command */
2405 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
2406 cmd.cp_outparm = mbox_info.mbi_out->mb_mapaddr;
2407 cmd.cp_inmod = 1; /* Get NodeDesc from port #1 */
2408 cmd.cp_opcode = MAD_IFC;
2409 cmd.cp_opmod = HERMON_CMD_MKEY_DONTCHECK; /* No MKey checking */
2410 cmd.cp_flags = sleepflag;
2411 status = hermon_cmd_post(state, &cmd);
2412 if (status != HERMON_CMD_SUCCESS) {
2413 goto getnodedesc_fail;
2414 }
2415
2416 /* Sync the mailbox to read the results */
2417 size = sizeof (sm_nodedesc_t);
2418 hermon_mbox_sync(mbox_info.mbi_out, HERMON_CMD_MADDATA_OFFSET,
2419 size, DDI_DMA_SYNC_FORCPU);
2420
2421 /* Copy GetNodeDesc response MAD into "nodedesc" */
2422 bcopy((void *)((uintptr_t)mbox_info.mbi_out->mb_addr +
2423 HERMON_CMD_MADDATA_OFFSET), nodedesc, size);
2424
2425 getnodedesc_fail:
2426 /* Free the mailbox */
2427 hermon_mbox_free(state, &mbox_info);
2428 return (status);
2429 }
2430
2431
2432 /*
2433 * hermon_getguidinfo_cmd_post()
2434 * Context: Can be called from interrupt or base context.
2435 */
2436 int
2437 hermon_getguidinfo_cmd_post(hermon_state_t *state, uint_t port,
2438 uint_t guidblock, uint_t sleepflag, sm_guidinfo_t *guidinfo)
2439 {
2440 hermon_mbox_info_t mbox_info;
2441 hermon_cmd_post_t cmd;
2442 uint32_t *mbox;
2443 uint_t size;
2444 int status, i;
2445
2446 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
2447
2448 /* Get "In" and "Out" mailboxes for the command */
2449 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX | HERMON_ALLOC_OUTMBOX;
2450 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
2451 if (status != HERMON_CMD_SUCCESS) {
2452 return (status);
2453 }
2454
2455 /* Build the GetGUIDInfo request MAD into the "In" mailbox */
2456 size = HERMON_CMD_MAD_IFC_SIZE;
2457 mbox = (uint32_t *)mbox_info.mbi_in->mb_addr;
2458 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[0], HERMON_CMD_MADHDR0);
2459 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[1], HERMON_CMD_MADHDR1);
2460 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[2], HERMON_CMD_MADHDR2);
2461 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[3], HERMON_CMD_MADHDR3);
2462 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[4], HERMON_CMD_GUIDINFO);
2463 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[5], guidblock);
2464 for (i = 6; i < (size >> 2); i++) {
2465 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[i], 0);
2466 }
2467
2468 /* Sync the mailbox for the device to read */
2469 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
2470
2471 /* Setup the Hermon "MAD_IFC" command */
2472 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
2473 cmd.cp_outparm = mbox_info.mbi_out->mb_mapaddr;
2474 cmd.cp_inmod = port;
2475 cmd.cp_opcode = MAD_IFC;
2476 cmd.cp_opmod = HERMON_CMD_MKEY_DONTCHECK; /* No MKey checking */
2477 cmd.cp_flags = sleepflag;
2478 status = hermon_cmd_post(state, &cmd);
2479 if (status != HERMON_CMD_SUCCESS) {
2480 goto getguidinfo_fail;
2481 }
2482
2483 /* Sync the mailbox to read the results */
2484 size = sizeof (sm_guidinfo_t);
2485 hermon_mbox_sync(mbox_info.mbi_out, HERMON_CMD_MADDATA_OFFSET,
2486 size, DDI_DMA_SYNC_FORCPU);
2487
2488 /*
2489 * Copy GetGUIDInfo response MAD into "guidinfo". Do any endian
2490 * swapping that may be necessary to flip the "guidinfo" fields
2491 */
2492 bcopy((void *)((uintptr_t)mbox_info.mbi_out->mb_addr +
2493 HERMON_CMD_MADDATA_OFFSET), guidinfo, size);
2494 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*guidinfo))
2495 HERMON_GETGUIDINFO_SWAP(guidinfo);
2496
2497 getguidinfo_fail:
2498 /* Free the mailbox */
2499 hermon_mbox_free(state, &mbox_info);
2500 return (status);
2501 }
2502
2503
2504 /*
2505 * hermon_getpkeytable_cmd_post()
2506 * Context: Can be called from interrupt or base context.
2507 */
2508 int
2509 hermon_getpkeytable_cmd_post(hermon_state_t *state, uint_t port,
2510 uint_t pkeyblock, uint_t sleepflag, sm_pkey_table_t *pkeytable)
2511 {
2512 hermon_mbox_info_t mbox_info;
2513 hermon_cmd_post_t cmd;
2514 uint32_t *mbox;
2515 uint_t size;
2516 int status, i;
2517
2518 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
2519
2520 /* Get "In" and "Out" mailboxes for the command */
2521 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX | HERMON_ALLOC_OUTMBOX;
2522 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
2523 if (status != HERMON_CMD_SUCCESS) {
2524 return (status);
2525 }
2526
2527 /* Build the GetPkeyTable request MAD into the "In" mailbox */
2528 size = HERMON_CMD_MAD_IFC_SIZE;
2529 mbox = (uint32_t *)mbox_info.mbi_in->mb_addr;
2530 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[0], HERMON_CMD_MADHDR0);
2531 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[1], HERMON_CMD_MADHDR1);
2532 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[2], HERMON_CMD_MADHDR2);
2533 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[3], HERMON_CMD_MADHDR3);
2534 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[4], HERMON_CMD_PKEYTBLE);
2535 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[5], pkeyblock);
2536 for (i = 6; i < (size >> 2); i++) {
2537 ddi_put32(mbox_info.mbi_in->mb_acchdl, &mbox[i], 0);
2538 }
2539
2540 /* Sync the mailbox for the device to read */
2541 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
2542
2543 /* Setup the Hermon "MAD_IFC" command */
2544 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
2545 cmd.cp_outparm = mbox_info.mbi_out->mb_mapaddr;
2546 cmd.cp_inmod = port;
2547 cmd.cp_opcode = MAD_IFC;
2548 cmd.cp_opmod = HERMON_CMD_MKEY_DONTCHECK; /* No MKey checking */
2549 cmd.cp_flags = sleepflag;
2550 status = hermon_cmd_post(state, &cmd);
2551 if (status != HERMON_CMD_SUCCESS) {
2552 goto getpkeytable_fail;
2553 }
2554
2555 /* Sync the mailbox to read the results */
2556 size = sizeof (sm_pkey_table_t);
2557 hermon_mbox_sync(mbox_info.mbi_out, HERMON_CMD_MADDATA_OFFSET,
2558 size, DDI_DMA_SYNC_FORCPU);
2559
2560 /*
2561 * Copy GetPKeyTable response MAD into "pkeytable". Do any endian
2562 * swapping that may be necessary to flip the "pkeytable" fields
2563 */
2564 bcopy((void *)((uintptr_t)mbox_info.mbi_out->mb_addr +
2565 HERMON_CMD_MADDATA_OFFSET), pkeytable, size);
2566 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*pkeytable))
2567 HERMON_GETPKEYTABLE_SWAP(pkeytable);
2568
2569 getpkeytable_fail:
2570 /* Free the mailbox */
2571 hermon_mbox_free(state, &mbox_info);
2572 return (status);
2573 }
2574
2575
2576 /*
2577 * hermon_write_mtt_cmd_post()
2578 * Context: Can be called from interrupt or base context.
2579 */
2580 int
2581 hermon_write_mtt_cmd_post(hermon_state_t *state, hermon_rsrc_t *mtt,
2582 uint64_t start_addr, uint_t nummtt, uint_t sleepflag)
2583 {
2584 hermon_mbox_info_t mbox_info;
2585 hermon_cmd_post_t cmd;
2586 uint64_t data;
2587 uint_t size;
2588 int status;
2589 int i;
2590
2591 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
2592
2593 /* Get an "In" mailbox for the command */
2594 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX;
2595 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
2596 if (status != HERMON_CMD_SUCCESS) {
2597 return (status);
2598 }
2599
2600 /*
2601 * The WRITE_MTT command input parameter contains the 64-bit addr of
2602 * the first target MTT, followed by 64 bits reserved, followed by an
2603 * array of MTT entries.
2604 *
2605 */
2606 ddi_put64(mbox_info.mbi_in->mb_acchdl,
2607 ((uint64_t *)mbox_info.mbi_in->mb_addr),
2608 start_addr);
2609
2610 ddi_put64(mbox_info.mbi_in->mb_acchdl,
2611 ((uint64_t *)mbox_info.mbi_in->mb_addr + 1), 0x0);
2612
2613 for (i = 0; i < nummtt; i++) {
2614 data = ((uint64_t *)mtt->hr_addr)[i];
2615 ddi_put64(mbox_info.mbi_in->mb_acchdl,
2616 ((uint64_t *)mbox_info.mbi_in->mb_addr + i + 2), data);
2617 }
2618
2619 /* Sync the mailbox for the device to read */
2620 size = (nummtt << HERMON_MTT_SIZE_SHIFT) + HERMON_CMD_WRITEMTT_RSVD_SZ;
2621 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
2622
2623 /* Setup and post Hermon "WRITE_MTT" command */
2624 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
2625 cmd.cp_outparm = 0;
2626 cmd.cp_inmod = nummtt;
2627 cmd.cp_opcode = WRITE_MTT;
2628 cmd.cp_opmod = 0;
2629 cmd.cp_flags = sleepflag;
2630 status = hermon_cmd_post(state, &cmd);
2631 if (status != HERMON_CMD_SUCCESS) {
2632 cmn_err(CE_CONT, "WRITE_MTT failed (0x%x)\n", status);
2633 }
2634
2635 /* Free the mailbox */
2636 hermon_mbox_free(state, &mbox_info);
2637 return (status);
2638 }
2639
2640
2641 /*
2642 * hermon_sync_tpt_cmd_post()
2643 * Context: Can be called from interrupt or base context.
2644 */
2645 int
2646 hermon_sync_tpt_cmd_post(hermon_state_t *state, uint_t sleepflag)
2647 {
2648 hermon_cmd_post_t cmd;
2649 int status;
2650
2651 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
2652
2653 /* Setup and post the Hermon "SYNC_TPT" command */
2654 cmd.cp_inparm = 0;
2655 cmd.cp_outparm = 0;
2656 cmd.cp_inmod = 0;
2657 cmd.cp_opcode = SYNC_TPT;
2658 cmd.cp_opmod = 0;
2659 cmd.cp_flags = sleepflag;
2660 status = hermon_cmd_post(state, &cmd);
2661
2662 return (status);
2663 }
2664
2665 /*
2666 * hermon_map_eq_cmd_post()
2667 * Context: Can be called from interrupt or base context.
2668 * (Currently called only from attach() and/or detach() path contexts)
2669 */
2670 int
2671 hermon_map_eq_cmd_post(hermon_state_t *state, uint_t map, uint_t eqcindx,
2672 uint64_t eqmapmask, uint_t sleepflag)
2673 {
2674 hermon_cmd_post_t cmd;
2675 int status;
2676
2677 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
2678
2679 /* Setup and post Hermon "MAP_EQ" command */
2680 cmd.cp_inparm = eqmapmask;
2681 cmd.cp_outparm = 0;
2682 cmd.cp_inmod = eqcindx;
2683 if (map != HERMON_CMD_MAP_EQ_EVT_MAP) {
2684 cmd.cp_inmod |= HERMON_CMD_UNMAP_EQ_MASK;
2685 }
2686 cmd.cp_opcode = MAP_EQ;
2687 cmd.cp_opmod = 0;
2688 cmd.cp_flags = sleepflag;
2689 status = hermon_cmd_post(state, &cmd);
2690 return (status);
2691 }
2692
2693
2694 /*
2695 * hermon_resize_cq_cmd_post()
2696 * Context: Can be called from interrupt or base context.
2697 */
2698 int
2699 hermon_resize_cq_cmd_post(hermon_state_t *state, hermon_hw_cqc_t *cqc,
2700 uint_t cqcindx, uint32_t *prod_indx, uint_t sleepflag)
2701 {
2702 hermon_mbox_info_t mbox_info;
2703 hermon_cmd_post_t cmd;
2704 uint64_t data;
2705 uint_t size;
2706 int status, i;
2707
2708 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
2709
2710 /* Get an "In" mailbox for the command */
2711 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX;
2712 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
2713 if (status != HERMON_CMD_SUCCESS) {
2714 return (status);
2715 }
2716
2717 /* Copy the Hermon "MODIFY_CQ" command into mailbox */
2718 size = sizeof (hermon_hw_cqc_t);
2719 for (i = 0; i < (size >> 3); i++) {
2720 data = ((uint64_t *)(void *)cqc)[i];
2721 ddi_put64(mbox_info.mbi_in->mb_acchdl,
2722 ((uint64_t *)mbox_info.mbi_in->mb_addr + i), data);
2723 }
2724
2725 /* Sync the mailbox for the device to read */
2726 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
2727
2728 /* Setup and post Hermon "MODIFY_CQ" command */
2729 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
2730 cmd.cp_outparm = 0; /* resize cq */
2731 cmd.cp_inmod = cqcindx;
2732 cmd.cp_opcode = MODIFY_CQ;
2733 cmd.cp_opmod = RESIZE_CQ;
2734 cmd.cp_flags = sleepflag;
2735 status = hermon_cmd_post(state, &cmd);
2736
2737 /*
2738 * New "producer index" is returned in the upper 32 bits of
2739 * command "outparam"
2740 */
2741 *prod_indx = (cmd.cp_outparm >> 32);
2742
2743 /* Free the mailbox */
2744 hermon_mbox_free(state, &mbox_info);
2745 return (status);
2746 }
2747
2748
2749 /*
2750 * hermon_modify_cq_cmd_post()
2751 * Context: Can be called from interrupt or base context.
2752 */
2753 int
2754 hermon_modify_cq_cmd_post(hermon_state_t *state, hermon_hw_cqc_t *cqc,
2755 uint_t cqcindx, uint_t opmod, uint_t sleepflag)
2756 {
2757 hermon_mbox_info_t mbox_info;
2758 hermon_cmd_post_t cmd;
2759 uint64_t data;
2760 uint_t size;
2761 int status, i;
2762
2763 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
2764
2765 /* Get an "In" mailbox for the command */
2766 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX;
2767 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
2768 if (status != HERMON_CMD_SUCCESS) {
2769 return (status);
2770 }
2771
2772 /* Copy the Hermon "MODIFY_CQ" command into mailbox */
2773 size = sizeof (hermon_hw_cqc_t);
2774 for (i = 0; i < (size >> 3); i++) {
2775 data = ((uint64_t *)(void *)cqc)[i];
2776 ddi_put64(mbox_info.mbi_in->mb_acchdl,
2777 ((uint64_t *)mbox_info.mbi_in->mb_addr + i), data);
2778 }
2779
2780 /* Sync the mailbox for the device to read */
2781 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
2782
2783 /* Setup and post Hermon "MODIFY_CQ" command */
2784 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
2785 cmd.cp_outparm = 0;
2786 cmd.cp_inmod = cqcindx;
2787 cmd.cp_opcode = MODIFY_CQ;
2788 cmd.cp_opmod = (uint16_t)opmod;
2789 cmd.cp_flags = sleepflag;
2790 status = hermon_cmd_post(state, &cmd);
2791
2792 /* Free the mailbox */
2793 hermon_mbox_free(state, &mbox_info);
2794 return (status);
2795 }
2796
2797
2798 /*
2799 * hermon_cmn_qp_cmd_post()
2800 * Context: Can be called from interrupt or base context.
2801 *
2802 * This is the common function for posting all the various types of
2803 * QP state transition related Hermon commands. Since some of the
2804 * commands differ from the others in the number (and type) of arguments
2805 * that each require, this routine does checks based on opcode type
2806 * (explained in more detail below).
2807 *
2808 * Note: This common function should be used only with the following
2809 * opcodes: RTS2SQD_QP, TOERR_QP, TORST_QP, RST2INIT_QP, INIT2INIT_QP,
2810 * INIT2RTR_QP, RTR2RTS_QP, RTS2RTS_QP, SQD2RTS_QP, and SQERR2RTS_QP.
2811 */
2812 int
2813 hermon_cmn_qp_cmd_post(hermon_state_t *state, uint_t opcode,
2814 hermon_hw_qpc_t *qp, uint_t qpindx, uint32_t opmask,
2815 uint_t sleepflag)
2816 {
2817 hermon_mbox_info_t mbox_info;
2818 hermon_cmd_post_t cmd;
2819 uint64_t data, in_mapaddr, out_mapaddr;
2820 uint_t size, flags, opmod;
2821 int status, i;
2822
2823 /*
2824 * Use the specified opcode type to set the appropriate parameters.
2825 * Specifically, we need to set in_mapaddr, out_mapaddr, flags, and
2826 * opmod (as necessary). Setting these parameters may also require
2827 * us to allocate an "In" or "Out" mailbox depending on the command
2828 * type.
2829 */
2830
2831 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
2832
2833 if (opcode == RTS2SQD_QP) {
2834 /*
2835 * Note: For RTS-to-SendQueueDrain state transitions we
2836 * always want to request the event generation from the
2837 * hardware. Though we may not notify the consumer of the
2838 * drained event, the decision to forward (or not) is made
2839 * later in the SQD event handler.
2840 */
2841 flags = HERMON_CMD_REQ_SQD_EVENT;
2842
2843 /*
2844 * The RTS2SQD_QP command uses no "In" or "Out" mailboxes (and
2845 * has no special opcode modifiers).
2846 */
2847 in_mapaddr = 0;
2848 out_mapaddr = 0;
2849 opmod = 0;
2850
2851 } else if (opcode == TOERR_QP) {
2852 /*
2853 * The TOERR_QP command uses no "In" or "Out" mailboxes, has no
2854 * special opcode modifiers, and takes no special flags.
2855 */
2856 in_mapaddr = 0;
2857 out_mapaddr = 0;
2858 opmod = 0;
2859 flags = 0;
2860
2861 } else if (opcode == TORST_QP) {
2862 /*
2863 * The TORST_QP command could take an "Out" mailbox, but we do
2864 * not require it here. It also does not takes any special
2865 * flags. It does however, take a HERMON_CMD_DIRECT_TO_RESET
2866 * opcode modifier, which indicates that the transition to
2867 * reset should happen without first moving the QP through the
2868 * Error state (and, hence, without generating any unnecessary
2869 * "flushed-in-error" completions).
2870 */
2871 in_mapaddr = 0;
2872 out_mapaddr = 0;
2873 opmod = HERMON_CMD_DIRECT_TO_RESET | HERMON_CMD_NO_OUTMBOX;
2874 flags = 0;
2875
2876 } else {
2877 /*
2878 * All the other QP state transition commands (RST2INIT_QP,
2879 * INIT2INIT_QP, INIT2RTR_QP, RTR2RTS_QP, RTS2RTS_QP,
2880 * SQD2RTS_QP, and SQERR2RTS_QP) require an "In" mailbox.
2881 * None of these require any special flags or opcode modifiers.
2882 */
2883 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX;
2884 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
2885 if (status != HERMON_CMD_SUCCESS) {
2886 return (status);
2887 }
2888 in_mapaddr = mbox_info.mbi_in->mb_mapaddr;
2889 out_mapaddr = 0;
2890 flags = 0;
2891 opmod = 0;
2892
2893 /* Copy the Hermon command into the "In" mailbox */
2894 size = sizeof (hermon_hw_qpc_t);
2895 for (i = 0; i < (size >> 3); i++) {
2896 data = ((uint64_t *)(void *)qp)[i];
2897 ddi_put64(mbox_info.mbi_in->mb_acchdl,
2898 ((uint64_t *)mbox_info.mbi_in->mb_addr + i + 1),
2899 data);
2900 }
2901 ddi_put32(mbox_info.mbi_in->mb_acchdl,
2902 ((uint32_t *)mbox_info.mbi_in->mb_addr), opmask);
2903
2904 /*
2905 * Sync the mailbox for the device to read. We have to add
2906 * eight bytes here to account for "opt_param_mask" and
2907 * proper alignment.
2908 */
2909 hermon_mbox_sync(mbox_info.mbi_in, 0, size + 8,
2910 DDI_DMA_SYNC_FORDEV);
2911 }
2912
2913 /* Setup and post Hermon QP state transition command */
2914 cmd.cp_inparm = in_mapaddr;
2915 cmd.cp_outparm = out_mapaddr;
2916 cmd.cp_inmod = qpindx | flags;
2917 cmd.cp_opcode = (uint16_t)opcode;
2918 cmd.cp_opmod = (uint16_t)opmod;
2919 cmd.cp_flags = sleepflag;
2920 status = hermon_cmd_post(state, &cmd);
2921
2922 /*
2923 * If we allocated a mailbox (either an "In" or an "Out") above,
2924 * then free it now before returning.
2925 */
2926 if ((opcode != RTS2SQD_QP) && (opcode != TOERR_QP) &&
2927 (opcode != TORST_QP)) {
2928 /* Free the mailbox */
2929 hermon_mbox_free(state, &mbox_info);
2930 }
2931 return (status);
2932 }
2933
2934
2935 /*
2936 * hermon_cmn_query_cmd_post()
2937 * Context: Can be called from interrupt or base context.
2938 *
2939 * This is the common function for posting all the various types of
2940 * Hermon query commands. All Hermon query commands require an "Out"
2941 * mailbox to be allocated for the resulting queried data.
2942 *
2943 * Note: This common function should be used only with the following
2944 * opcodes: QUERY_DEV_LIM, QUERY_FW, QUERY_DDR, QUERY_ADAPTER, QUERY_PORT
2945 * QUERY_HCA, QUERY_MPT, QUERY_EQ, QUERY_CQ, and QUERY_QP.
2946 * With support of FCoIB, this also supports QUERY_FC.
2947 */
2948 int
2949 hermon_cmn_query_cmd_post(hermon_state_t *state, uint_t opcode, uint_t opmod,
2950 uint_t queryindx, void *query, uint_t size, uint_t sleepflag)
2951 {
2952 hermon_mbox_info_t mbox_info;
2953 hermon_cmd_post_t cmd;
2954 uint64_t data;
2955 uint_t offset;
2956 int status, i;
2957
2958 bzero(&cmd, sizeof (hermon_cmd_post_t));
2959
2960 /* Get an "Out" mailbox for the command */
2961 mbox_info.mbi_alloc_flags = HERMON_ALLOC_OUTMBOX;
2962 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
2963 if (status != HERMON_CMD_SUCCESS) {
2964 return (status);
2965 }
2966
2967 /* Setup and post the Hermon query command */
2968 cmd.cp_inparm = 0;
2969 cmd.cp_outparm = mbox_info.mbi_out->mb_mapaddr;
2970 cmd.cp_inmod = queryindx;
2971 cmd.cp_opcode = (uint16_t)opcode;
2972 cmd.cp_opmod = (uint16_t)opmod;
2973 cmd.cp_flags = sleepflag;
2974 status = hermon_cmd_post(state, &cmd);
2975 if (status != HERMON_CMD_SUCCESS) {
2976 goto cmn_query_fail;
2977 }
2978
2979 /* Sync the mailbox to read the results */
2980 hermon_mbox_sync(mbox_info.mbi_out, 0, size, DDI_DMA_SYNC_FORCPU);
2981
2982 /*
2983 * QUERY_QP is handled somewhat differently than the other query
2984 * commands. For QUERY_QP, the actual queried data is offset into
2985 * the mailbox (by one 64-bit word).
2986 */
2987 offset = (opcode == QUERY_QP) ? 1 : 0;
2988
2989 /* Copy query command results into "query" */
2990 for (i = 0; i < (size >> 3); i++) {
2991 data = ddi_get64(mbox_info.mbi_out->mb_acchdl,
2992 ((uint64_t *)mbox_info.mbi_out->mb_addr + i + offset));
2993 ((uint64_t *)query)[i] = data;
2994 }
2995
2996 cmn_query_fail:
2997 /* Free the mailbox */
2998 hermon_mbox_free(state, &mbox_info);
2999 return (status);
3000 }
3001
3002
3003 /*
3004 * hermon_cmn_ownership_cmd_post()
3005 * Context: Can be called from interrupt or base context.
3006 *
3007 * This is the common function for posting all the various types of
3008 * Hermon HW/SW resource ownership commands. Since some of the commands
3009 * differ from the others in the direction of ownership change (i.e.
3010 * from HW ownership to SW, or vice versa), they differ in the type of
3011 * mailbox and specific handling that each requires. This routine does
3012 * certain checks based on opcode type to determine the direction of
3013 * the transition and to correctly handle the request.
3014 *
3015 * Note: This common function should be used only with the following
3016 * opcodes: HW2SW_MPT, HW2SW_EQ, HW2SW_CQ, SW2HW_MPT, SW2HW_EQ, and
3017 * SW2HW_CQ
3018 */
3019 int
3020 hermon_cmn_ownership_cmd_post(hermon_state_t *state, uint_t opcode,
3021 void *hwrsrc, uint_t size, uint_t hwrsrcindx, uint_t sleepflag)
3022 {
3023 hermon_mbox_info_t mbox_info;
3024 hermon_cmd_post_t cmd;
3025 uint64_t data, in_mapaddr, out_mapaddr;
3026 uint_t direction, opmod;
3027 int status, i;
3028
3029 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3030
3031 /*
3032 * Determine the direction of the ownership transfer based on the
3033 * provided opcode
3034 */
3035 if ((opcode == HW2SW_MPT) || (opcode == HW2SW_EQ) ||
3036 (opcode == HW2SW_CQ) || (opcode == HW2SW_SRQ)) {
3037 direction = HERMON_CMD_RSRC_HW2SW;
3038
3039 } else if ((opcode == SW2HW_MPT) || (opcode == SW2HW_EQ) ||
3040 (opcode == SW2HW_CQ) || (opcode == SW2HW_SRQ)) {
3041 direction = HERMON_CMD_RSRC_SW2HW;
3042
3043 } else {
3044 return (HERMON_CMD_INVALID_STATUS);
3045 }
3046
3047 /*
3048 * If hwrsrc is NULL then we do not allocate a mailbox. This is used
3049 * in the case of memory deregister where the out mailbox is not
3050 * needed. In the case of re-register, we do use the hwrsrc.
3051 *
3052 * Otherwise, If ownership transfer is going from hardware to software,
3053 * then allocate an "Out" mailbox. This will be filled in later as a
3054 * result of the Hermon command.
3055 *
3056 * And if the ownership transfer is going from software to hardware,
3057 * then we need an "In" mailbox, and we need to fill it in and sync it
3058 * (if necessary). Then the mailbox can be passed to the Hermon
3059 * firmware.
3060 *
3061 * For the HW2SW (dereg) case, we only use an out mbox if hwrsrc is !=
3062 * NULL. This implies a re-reg, and the out mbox must be used. If
3063 * hwrsrc is == NULL, then we can save some time and resources by not
3064 * using an out mbox at all. We must set opmod to HERMON_CMD_DO_OUTMBOX
3065 * and HERMON_CMD_NO_OUTMBOX appropriately in this case.
3066 *
3067 * For the SW2HW (reg) case, no out mbox is possible. We set opmod to
3068 * 0 anyway, but this field is not used in this case.
3069 */
3070 if (direction == HERMON_CMD_RSRC_HW2SW) {
3071 if (hwrsrc != NULL) {
3072 mbox_info.mbi_alloc_flags = HERMON_ALLOC_OUTMBOX;
3073 status = hermon_mbox_alloc(state, &mbox_info,
3074 sleepflag);
3075 if (status != HERMON_CMD_SUCCESS) {
3076 return (status);
3077 }
3078 in_mapaddr = 0;
3079 out_mapaddr = mbox_info.mbi_out->mb_mapaddr;
3080 opmod = HERMON_CMD_DO_OUTMBOX;
3081 } else {
3082 in_mapaddr = 0;
3083 out_mapaddr = 0;
3084 opmod = HERMON_CMD_NO_OUTMBOX;
3085 }
3086 } else { /* HERMON_CMD_RSRC_SW2HW */
3087 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX;
3088 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
3089 if (status != HERMON_CMD_SUCCESS) {
3090 return (status);
3091 }
3092
3093 /* Copy the SW2HW ownership command into mailbox */
3094 for (i = 0; i < (size >> 3); i++) {
3095 data = ((uint64_t *)hwrsrc)[i];
3096 ddi_put64(mbox_info.mbi_in->mb_acchdl,
3097 ((uint64_t *)mbox_info.mbi_in->mb_addr + i),
3098 data);
3099 }
3100
3101 /* Sync the mailbox for the device to read */
3102 hermon_mbox_sync(mbox_info.mbi_in, 0, size,
3103 DDI_DMA_SYNC_FORDEV);
3104
3105 in_mapaddr = mbox_info.mbi_in->mb_mapaddr;
3106 out_mapaddr = 0;
3107 opmod = 0;
3108 }
3109
3110 /* Setup and post the Hermon ownership command */
3111 cmd.cp_inparm = in_mapaddr;
3112 cmd.cp_outparm = out_mapaddr;
3113 cmd.cp_inmod = hwrsrcindx;
3114 cmd.cp_opcode = (uint16_t)opcode;
3115 cmd.cp_opmod = (uint16_t)opmod;
3116 cmd.cp_flags = sleepflag;
3117 status = hermon_cmd_post(state, &cmd);
3118 if (status != HERMON_CMD_SUCCESS) {
3119 goto cmn_ownership_fail;
3120 }
3121
3122 /*
3123 * As mentioned above, for HW2SW ownership transfers we need to
3124 * sync (if necessary) and copy out the resulting data from the
3125 * "Out" mailbox" (assuming the above command was successful).
3126 */
3127 if (direction == HERMON_CMD_RSRC_HW2SW && hwrsrc != NULL) {
3128
3129 /* Sync the mailbox to read the results */
3130 hermon_mbox_sync(mbox_info.mbi_out, 0, size,
3131 DDI_DMA_SYNC_FORCPU);
3132
3133 /* Copy HW2SW ownership command results into "hwrsrc" */
3134 for (i = 0; i < (size >> 3); i++) {
3135 data = ddi_get64(mbox_info.mbi_out->mb_acchdl,
3136 ((uint64_t *)mbox_info.mbi_out->mb_addr + i));
3137 ((uint64_t *)hwrsrc)[i] = data;
3138 }
3139 }
3140
3141 cmn_ownership_fail:
3142 if (hwrsrc != NULL) {
3143 /* Free the mailbox */
3144 hermon_mbox_free(state, &mbox_info);
3145 }
3146 return (status);
3147 }
3148
3149
3150 /*
3151 * hermon_conf_special_qp_cmd_post()
3152 * Context: Can be called from interrupt or base context.
3153 */
3154 /*ARGSUSED*/
3155 int
3156 hermon_conf_special_qp_cmd_post(hermon_state_t *state, uint_t qpindx,
3157 uint_t qptype, uint_t sleepflag, uint_t opmod)
3158 {
3159 hermon_cmd_post_t cmd;
3160 int status;
3161
3162 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3163
3164 /* Setup and post Hermon "CONF_SPECIAL_QP" command */
3165 cmd.cp_inparm = 0;
3166 cmd.cp_outparm = 0;
3167 cmd.cp_inmod = qpindx & 0x00FFFFF8; /* mask off low 3 bits */
3168 cmd.cp_opcode = CONF_SPECIAL_QP;
3169 cmd.cp_opmod = (uint16_t)opmod;
3170 cmd.cp_flags = sleepflag;
3171 status = hermon_cmd_post(state, &cmd);
3172
3173 return (status);
3174 }
3175
3176
3177 /*
3178 * hermon_get_heart_beat_rq_cmd_post()
3179 * Context: Can be called only from kernel or interrupt context
3180 */
3181 int
3182 hermon_get_heart_beat_rq_cmd_post(hermon_state_t *state, uint_t qpindx,
3183 uint64_t *outparm)
3184 {
3185 hermon_cmd_post_t cmd;
3186 int status;
3187
3188 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3189
3190 /* Setup and post the Hermon "HEART_BEAT_RQ" command */
3191 cmd.cp_inparm = 0;
3192 cmd.cp_outparm = 0;
3193 cmd.cp_inmod = qpindx;
3194 cmd.cp_opcode = HEART_BEAT_RQ;
3195 cmd.cp_opmod = 0;
3196 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN;
3197 status = hermon_cmd_post(state, &cmd);
3198
3199 /*
3200 * Return immediate out param through argument pointer.
3201 */
3202 *outparm = cmd.cp_outparm;
3203 return (status);
3204 }
3205
3206
3207 /*
3208 * hermon_mgid_hash_cmd_post()
3209 * Context: Can be called from interrupt or base context.
3210 */
3211 int
3212 hermon_mgid_hash_cmd_post(hermon_state_t *state, uint64_t mgid_h,
3213 uint64_t mgid_l, uint64_t *mgid_hash, uint_t sleepflag)
3214 {
3215 hermon_mbox_info_t mbox_info;
3216 hermon_cmd_post_t cmd;
3217 int status;
3218
3219 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3220
3221 /* Get an "In" mailbox for the command */
3222 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX;
3223 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
3224 if (status != HERMON_CMD_SUCCESS) {
3225 return (status);
3226 }
3227
3228 /* Copy the Hermon "MGID_HASH" command into mailbox */
3229 ddi_put64(mbox_info.mbi_in->mb_acchdl,
3230 ((uint64_t *)mbox_info.mbi_in->mb_addr + 0), mgid_h);
3231 ddi_put64(mbox_info.mbi_in->mb_acchdl,
3232 ((uint64_t *)mbox_info.mbi_in->mb_addr + 1), mgid_l);
3233
3234 /* Sync the mailbox for the device to read */
3235 hermon_mbox_sync(mbox_info.mbi_in, 0, HERMON_CMD_MGIDHASH_SZ,
3236 DDI_DMA_SYNC_FORDEV);
3237
3238 /* Setup and post the Hermon "MGID_HASH" command */
3239 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
3240 cmd.cp_outparm = 0;
3241 cmd.cp_inmod = 0;
3242 cmd.cp_opcode = MGID_HASH;
3243 cmd.cp_opmod = 0;
3244 cmd.cp_flags = sleepflag;
3245 status = hermon_cmd_post(state, &cmd);
3246
3247 /* MGID hash value is returned in command "outparam" */
3248 *mgid_hash = cmd.cp_outparm;
3249
3250 /* Free the mailbox */
3251 hermon_mbox_free(state, &mbox_info);
3252 return (status);
3253 }
3254
3255
3256 /*
3257 * hermon_read_mgm_cmd_post()
3258 * Context: Can be called from interrupt or base context.
3259 *
3260 * Note: It is assumed that the "mcg" parameter is actually a pointer to a
3261 * "hermon_hw_mcg_t" struct and some number of "hermon_hw_mcg_qp_list_t"
3262 * structs. Combined size should be equal to result of HERMON_MCGMEM_SZ()
3263 * macro.
3264 */
3265 int
3266 hermon_read_mgm_cmd_post(hermon_state_t *state, hermon_hw_mcg_t *mcg,
3267 uint_t mcgindx, uint_t sleepflag)
3268 {
3269 hermon_mbox_info_t mbox_info;
3270 hermon_cmd_post_t cmd;
3271 uint64_t data;
3272 uint32_t data32;
3273 uint_t size, hdrsz, qplistsz;
3274 int status, i;
3275
3276 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3277
3278 /* Get an "Out" mailbox for the results */
3279 mbox_info.mbi_alloc_flags = HERMON_ALLOC_OUTMBOX;
3280 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
3281 if (status != HERMON_CMD_SUCCESS) {
3282 return (status);
3283 }
3284
3285 /* Setup and post Hermon "READ_MGM" command */
3286 cmd.cp_inparm = 0;
3287 cmd.cp_outparm = mbox_info.mbi_out->mb_mapaddr;
3288 cmd.cp_inmod = mcgindx;
3289 cmd.cp_opcode = READ_MGM;
3290 cmd.cp_opmod = 0;
3291 cmd.cp_flags = sleepflag;
3292 status = hermon_cmd_post(state, &cmd);
3293 if (status != HERMON_CMD_SUCCESS) {
3294 goto read_mgm_fail;
3295 }
3296
3297 /* Sync the mailbox to read the results */
3298 size = HERMON_MCGMEM_SZ(state);
3299 hermon_mbox_sync(mbox_info.mbi_out, 0, size, DDI_DMA_SYNC_FORCPU);
3300
3301 /* Copy the READ_MGM command results into "mcg" */
3302 hdrsz = sizeof (hermon_hw_mcg_t);
3303 for (i = 0; i < (hdrsz >> 3); i++) {
3304 data = ddi_get64(mbox_info.mbi_out->mb_acchdl,
3305 ((uint64_t *)mbox_info.mbi_out->mb_addr + i));
3306 ((uint64_t *)mcg)[i] = data;
3307 }
3308 qplistsz = size - hdrsz;
3309 for (i = 0; i < (qplistsz >> 2); i++) {
3310 data32 = ddi_get32(mbox_info.mbi_out->mb_acchdl,
3311 ((uint32_t *)mbox_info.mbi_out->mb_addr + i + 8));
3312 ((uint32_t *)mcg)[i + 8] = data32;
3313 }
3314
3315 read_mgm_fail:
3316 /* Free the mailbox */
3317 hermon_mbox_free(state, &mbox_info);
3318 return (status);
3319 }
3320
3321
3322 /*
3323 * hermon_write_mgm_cmd_post()
3324 * Context: Can be called from interrupt or base context.
3325 *
3326 * Note: It is assumed that the "mcg" parameter is actually a pointer to a
3327 * "hermon_hw_mcg_t" struct and some number of "hermon_hw_mcg_qp_list_t"
3328 * structs. Combined size should be equal to result of HERMON_MCGMEM_SZ()
3329 * macro.
3330 */
3331 int
3332 hermon_write_mgm_cmd_post(hermon_state_t *state, hermon_hw_mcg_t *mcg,
3333 uint_t mcgindx, uint_t sleepflag)
3334 {
3335 hermon_mbox_info_t mbox_info;
3336 hermon_cmd_post_t cmd;
3337 uint64_t data;
3338 uint_t size, hdrsz, qplistsz;
3339 int status, i;
3340
3341 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3342
3343 /* Get an "In" mailbox for the command */
3344 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX;
3345 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
3346 if (status != HERMON_CMD_SUCCESS) {
3347 return (status);
3348 }
3349
3350 /* Copy the Hermon "WRITE_MGM" command into mailbox */
3351 size = HERMON_MCGMEM_SZ(state);
3352 hdrsz = sizeof (hermon_hw_mcg_t);
3353 for (i = 0; i < (hdrsz >> 3); i++) {
3354 data = ((uint64_t *)mcg)[i];
3355 ddi_put64(mbox_info.mbi_in->mb_acchdl,
3356 ((uint64_t *)mbox_info.mbi_in->mb_addr + i), data);
3357 }
3358 qplistsz = size - hdrsz;
3359 for (i = 0; i < (qplistsz >> 2); i++) {
3360 data = ((uint32_t *)mcg)[i + 8];
3361 ddi_put32(mbox_info.mbi_in->mb_acchdl,
3362 ((uint32_t *)mbox_info.mbi_in->mb_addr + i + 8), data);
3363 }
3364
3365 /* Sync the mailbox for the device to read */
3366 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
3367
3368 /* Setup and post Hermon "WRITE_MGM" command */
3369 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
3370 cmd.cp_outparm = 0;
3371 cmd.cp_inmod = mcgindx;
3372 cmd.cp_opcode = WRITE_MGM;
3373 cmd.cp_opmod = 0;
3374 cmd.cp_flags = sleepflag;
3375 status = hermon_cmd_post(state, &cmd);
3376
3377 /* Free the mailbox */
3378 hermon_mbox_free(state, &mbox_info);
3379 return (status);
3380 }
3381
3382 /*
3383 * hermon_resize_srq_cmd_post()
3384 * Context: Can be called from interrupt or base context.
3385 */
3386
3387 int hermon_resize_srq_cmd_post(hermon_state_t *state, hermon_hw_srqc_t *srq,
3388 uint_t srqnum, uint_t sleepflag)
3389 {
3390 hermon_mbox_info_t mbox_info;
3391 hermon_cmd_post_t cmd;
3392 uint64_t data;
3393 uint_t size;
3394 int status, i;
3395
3396 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3397
3398 /* Get an "In" mailbox for the command */
3399 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX;
3400 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
3401 if (status != HERMON_CMD_SUCCESS) {
3402 return (status);
3403 }
3404
3405 /* Copy the Hermon "RESIZE_SRQ" command into mailbox */
3406 size = sizeof (hermon_hw_srqc_t);
3407 for (i = 0; i < (size >> 3); i++) {
3408 data = ((uint64_t *)(void *)srq)[i];
3409 ddi_put64(mbox_info.mbi_in->mb_acchdl,
3410 ((uint64_t *)mbox_info.mbi_in->mb_addr + i), data);
3411 }
3412
3413 /* Sync the mailbox for the device to read */
3414 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
3415
3416 /* Setup and post Hermon "RESIZE_SRQ" command */
3417 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
3418 cmd.cp_outparm = 0;
3419 cmd.cp_inmod = srqnum;
3420 cmd.cp_opcode = RESIZE_SRQ;
3421 cmd.cp_opmod = 0;
3422 cmd.cp_flags = sleepflag;
3423 status = hermon_cmd_post(state, &cmd);
3424
3425 /* Free the mailbox */
3426 hermon_mbox_free(state, &mbox_info);
3427 return (status);
3428 }
3429 /*
3430 * hermon_modify_mpt_cmd_post()
3431 * Context: Can be called from interrupt or base context.
3432 */
3433 int
3434 hermon_modify_mpt_cmd_post(hermon_state_t *state, hermon_hw_dmpt_t *mpt,
3435 uint_t mptindx, uint_t flags, uint_t sleepflag)
3436 {
3437 hermon_mbox_info_t mbox_info;
3438 hermon_cmd_post_t cmd;
3439 uint64_t data;
3440 uint_t size;
3441 int status, i;
3442
3443 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3444
3445 /* Get an "In" mailbox for the command */
3446 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX;
3447 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
3448 if (status != HERMON_CMD_SUCCESS) {
3449 return (status);
3450 }
3451
3452 /* Copy the Hermon "MODIFY_MPT" command into mailbox */
3453 size = sizeof (hermon_hw_dmpt_t);
3454 for (i = 0; i < (size >> 3); i++) {
3455 data = ((uint64_t *)mpt)[i];
3456 ddi_put64(mbox_info.mbi_in->mb_acchdl,
3457 ((uint64_t *)mbox_info.mbi_in->mb_addr + i), data);
3458 }
3459
3460 /* Sync the mailbox for the device to read */
3461 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
3462
3463 /* Setup and post Hermon "MODIFY_MPT" command */
3464 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
3465 cmd.cp_outparm = 0;
3466 cmd.cp_inmod = mptindx;
3467 cmd.cp_opcode = MODIFY_MPT;
3468 cmd.cp_opmod = (uint16_t)flags;
3469 cmd.cp_flags = sleepflag;
3470 status = hermon_cmd_post(state, &cmd);
3471
3472 /* Free the mailbox */
3473 hermon_mbox_free(state, &mbox_info);
3474 return (status);
3475 }
3476
3477
3478 /*
3479 * hermon_config_fc_cmd_post()
3480 * Context: Can be called from user or kernel context.
3481 * This can do either a basic config passing in
3482 * *hermon_hw_config_fc_basic_s, or config the N_Port table.
3483 * passing in pointer to an array of 32-bit id's
3484 * Note that either one needs to be cast to void *
3485 */
3486 int
3487 hermon_config_fc_cmd_post(hermon_state_t *state, void *cfginfo, int enable,
3488 int selector, int n_ports, int portnum, uint_t sleepflag)
3489 {
3490 hermon_mbox_info_t mbox_info;
3491 hermon_cmd_post_t cmd;
3492 uint64_t data;
3493 uint32_t portid;
3494 uint_t size;
3495 int status, i;
3496
3497 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3498
3499 /* Get an "In" mailbox for the command */
3500 mbox_info.mbi_alloc_flags = HERMON_ALLOC_INMBOX;
3501 status = hermon_mbox_alloc(state, &mbox_info, sleepflag);
3502 if (status != HERMON_CMD_SUCCESS) {
3503 return (status);
3504 }
3505
3506 /* Copy the appropriate info into mailbox */
3507 if (selector == HERMON_HW_FC_CONF_BASIC) { /* basic info */
3508 size = sizeof (hermon_hw_config_fc_basic_t);
3509 for (i = 0; i < (size >> 3); i++) {
3510 data = ((uint64_t *)cfginfo)[i];
3511 ddi_put64(mbox_info.mbi_in->mb_acchdl,
3512 ((uint64_t *)mbox_info.mbi_in->mb_addr + i), data);
3513 }
3514 } else { /* NPort config */
3515 ASSERT(selector == HERMON_HW_FC_CONF_NPORT);
3516 size = n_ports * sizeof (uint32_t);
3517 /*
3518 * n_ports must == number queried from card
3519 *
3520 * passed in is an array but for little endian needs to
3521 * be rearranged in the mbox
3522 */
3523 for (i = 0; i < (size >> 3); i++) {
3524 portid = ((uint32_t *)cfginfo)[i * 2];
3525 data = (uint64_t)portid << 32;
3526 if (i * 2 < n_ports) {
3527 portid = ((uint32_t *)cfginfo)[i * 2 + 1];
3528 data |= portid;
3529 }
3530 ddi_put64(mbox_info.mbi_in->mb_acchdl,
3531 ((uint64_t *)mbox_info.mbi_in->mb_addr + i), data);
3532 }
3533 }
3534
3535 /* Sync the mailbox for the device to read */
3536 hermon_mbox_sync(mbox_info.mbi_in, 0, size, DDI_DMA_SYNC_FORDEV);
3537
3538 /* Setup and post Hermon "CONFIG_FC" command */
3539 cmd.cp_inparm = mbox_info.mbi_in->mb_mapaddr;
3540 cmd.cp_outparm = 0;
3541 cmd.cp_inmod = (uint32_t)(selector | portnum);
3542 cmd.cp_opcode = CONFIG_FC;
3543 cmd.cp_opmod = (uint16_t)enable;
3544 cmd.cp_flags = sleepflag;
3545 status = hermon_cmd_post(state, &cmd);
3546
3547 /* Free the mailbox */
3548 hermon_mbox_free(state, &mbox_info);
3549 return (status);
3550 }
3551
3552 /*
3553 * hermon_sense_port_post() - used to send protocol running on a port
3554 * Context: Can be called from interrupt or base context
3555 */
3556
3557 int
3558 hermon_sense_port_post(hermon_state_t *state, uint_t portnum,
3559 uint32_t *protocol)
3560 {
3561 hermon_cmd_post_t cmd;
3562 int status;
3563
3564 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3565
3566 /* Setup and post Hermon "CMD_NOP" command */
3567 cmd.cp_inparm = 0;
3568 cmd.cp_outparm = 0;
3569 cmd.cp_inmod = (uint32_t)portnum;
3570 cmd.cp_opcode = SENSE_PORT;
3571 cmd.cp_opmod = 0;
3572 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN;
3573 status = hermon_cmd_post(state, &cmd);
3574 if (status == HERMON_CMD_SUCCESS) *protocol = (uint32_t)cmd.cp_outparm;
3575 return (status);
3576 }
3577
3578
3579 /*
3580 * CONFIG_INT_MOD - used to configure INTERRUPT moderation
3581 * if command fails, *health is invalid/undefined
3582 */
3583 int
3584 hermon_config_int_mod(hermon_state_t *state, uint_t min_delay, uint_t vector)
3585 {
3586 hermon_cmd_post_t cmd;
3587 int status;
3588 uint64_t inparm = 0;
3589
3590 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3591
3592 /* Setup and post Hermon "CONFIG_INT_MOD" command */
3593 inparm = (((uint64_t)min_delay & 0xFFFF) << 48) ||
3594 (((uint64_t)vector & 0xFFFF) << 32);
3595
3596 cmd.cp_inparm = inparm;
3597 cmd.cp_outparm = 0;
3598 cmd.cp_inmod = 0;
3599 cmd.cp_opcode = CONFIG_INT_MOD;
3600 cmd.cp_opmod = 0;
3601 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN;
3602 status = hermon_cmd_post(state, &cmd);
3603 return (status);
3604 }
3605
3606
3607 int
3608 hermon_nop_post(hermon_state_t *state, uint_t interval, uint_t sleep)
3609 {
3610 hermon_cmd_post_t cmd;
3611 int status;
3612
3613 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3614
3615 /* Setup and post Hermon "CMD_NOP" command */
3616 cmd.cp_inparm = 0;
3617 cmd.cp_outparm = 0;
3618 cmd.cp_inmod = interval;
3619 cmd.cp_opcode = CMD_NOP;
3620 cmd.cp_opmod = 0;
3621 cmd.cp_flags = HERMON_CMD_SLEEP_NOSPIN;
3622 if (sleep) cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN;
3623 status = hermon_cmd_post(state, &cmd);
3624 return (status);
3625 }
3626
3627 int
3628 hermon_hw_health_check(hermon_state_t *state, int *health)
3629 {
3630 hermon_cmd_post_t cmd;
3631 int status;
3632
3633 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3634
3635 /* Setup and post Hermon "CMD_NOP" command */
3636 cmd.cp_inparm = 0;
3637 cmd.cp_outparm = 0;
3638 cmd.cp_inmod = 0;
3639 cmd.cp_opcode = HW_HEALTH_CHECK;
3640 cmd.cp_opmod = 0;
3641 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN;
3642 status = hermon_cmd_post(state, &cmd);
3643 *health = (int)cmd.cp_outparm;
3644 return (status);
3645 }
3646
3647 int
3648 hermon_setdebug_post(hermon_state_t *state)
3649 {
3650 hermon_cmd_post_t cmd;
3651 int status;
3652
3653 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3654
3655 /* Setup and post Hermon "CMD_NOP" command */
3656 cmd.cp_inparm = 0xFFFFFFFFFFFFFFFF;
3657 cmd.cp_outparm = 0;
3658 cmd.cp_inmod = 0;
3659 cmd.cp_opcode = SET_DEBUG_MSG;
3660 cmd.cp_opmod = 0;
3661 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN;
3662 status = hermon_cmd_post(state, &cmd);
3663 return (status);
3664 }
3665
3666
3667 int
3668 hermon_read_mtt_cmd_post(hermon_state_t *state, uint64_t mtt_addr,
3669 hermon_hw_mtt_t *mtt)
3670 {
3671
3672 hermon_cmd_post_t cmd;
3673 hermon_mbox_info_t mbox_info;
3674 int i, status;
3675 uint_t size;
3676 uint64_t data;
3677
3678 bzero((void *)&cmd, sizeof (hermon_cmd_post_t));
3679
3680 /* Get an "Out" mailbox for the command */
3681 mbox_info.mbi_alloc_flags = HERMON_ALLOC_OUTMBOX;
3682 status = hermon_mbox_alloc(state, &mbox_info, HERMON_CMD_SLEEP_NOSPIN);
3683 if (status != HERMON_CMD_SUCCESS) {
3684 return (status);
3685 }
3686
3687 /* Setup and post the "READ_MTT" command */
3688 cmd.cp_inparm = mtt_addr;
3689 cmd.cp_outparm = mbox_info.mbi_out->mb_mapaddr;
3690 cmd.cp_inmod = 1;
3691 cmd.cp_opcode = READ_MTT;
3692 cmd.cp_opmod = 0;
3693 cmd.cp_flags = HERMON_CMD_NOSLEEP_SPIN;
3694 status = hermon_cmd_post(state, &cmd);
3695 if (status != HERMON_CMD_SUCCESS) {
3696 return (status);
3697 }
3698
3699 /* Sync the mailbox to read the results */
3700 size = sizeof (hermon_hw_mtt_t);
3701 hermon_mbox_sync(mbox_info.mbi_out, 0, size, DDI_DMA_SYNC_FORCPU);
3702
3703 /* Copy mtt read out */
3704 for (i = 0; i < (size >> 3); i++) {
3705 data = ddi_get64(mbox_info.mbi_out->mb_acchdl,
3706 ((uint64_t *)mbox_info.mbi_out->mb_addr + i));
3707 ((uint64_t *)(void *)mtt)[i] = data;
3708 }
3709
3710 /* Free the mailbox */
3711 hermon_mbox_free(state, &mbox_info);
3712 return (status);
3713 }