1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * Copyright (c) 2000 to 2009, LSI Corporation.
29 * All rights reserved.
30 *
31 * Redistribution and use in source and binary forms of all code within
32 * this file that is exclusively owned by LSI, with or without
33 * modification, is permitted provided that, in addition to the CDDL 1.0
34 * License requirements, the following conditions are met:
35 *
36 * Neither the name of the author nor the names of its contributors may be
37 * used to endorse or promote products derived from this software without
38 * specific prior written permission.
39 *
40 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
41 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
42 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
43 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
44 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
45 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
46 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
47 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
48 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
49 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
50 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
51 * DAMAGE.
52 */
53
54 /*
55 * mptsas_init - This file contains all the functions used to initialize
56 * MPT2.0 based hardware.
57 */
58
59 #if defined(lint) || defined(DEBUG)
60 #define MPTSAS_DEBUG
61 #endif
62
63 /*
64 * standard header files
65 */
66 #include <sys/note.h>
67 #include <sys/scsi/scsi.h>
68
69 #pragma pack(1)
70 #include <sys/scsi/adapters/mpt_sas/mpi/mpi2_type.h>
71 #include <sys/scsi/adapters/mpt_sas/mpi/mpi2.h>
72 #include <sys/scsi/adapters/mpt_sas/mpi/mpi2_cnfg.h>
73 #include <sys/scsi/adapters/mpt_sas/mpi/mpi2_init.h>
74 #include <sys/scsi/adapters/mpt_sas/mpi/mpi2_ioc.h>
75 #include <sys/scsi/adapters/mpt_sas/mpi/mpi2_tool.h>
76 #pragma pack()
77 /*
78 * private header files.
79 */
80 #include <sys/scsi/adapters/mpt_sas/mptsas_var.h>
81
82 static int mptsas_ioc_do_get_facts(mptsas_t *mpt, caddr_t memp, int var,
83 ddi_acc_handle_t accessp);
84 static int mptsas_ioc_do_get_facts_reply(mptsas_t *mpt, caddr_t memp, int var,
85 ddi_acc_handle_t accessp);
86 static int mptsas_ioc_do_get_port_facts(mptsas_t *mpt, caddr_t memp, int var,
87 ddi_acc_handle_t accessp);
88 static int mptsas_ioc_do_get_port_facts_reply(mptsas_t *mpt, caddr_t memp,
89 int var, ddi_acc_handle_t accessp);
90 static int mptsas_ioc_do_enable_port(mptsas_t *mpt, caddr_t memp, int var,
91 ddi_acc_handle_t accessp);
92 static int mptsas_ioc_do_enable_port_reply(mptsas_t *mpt, caddr_t memp, int var,
93 ddi_acc_handle_t accessp);
94 static int mptsas_ioc_do_enable_event_notification(mptsas_t *mpt, caddr_t memp,
95 int var, ddi_acc_handle_t accessp);
96 static int mptsas_ioc_do_enable_event_notification_reply(mptsas_t *mpt,
97 caddr_t memp, int var, ddi_acc_handle_t accessp);
98 static int mptsas_do_ioc_init(mptsas_t *mpt, caddr_t memp, int var,
99 ddi_acc_handle_t accessp);
100 static int mptsas_do_ioc_init_reply(mptsas_t *mpt, caddr_t memp, int var,
101 ddi_acc_handle_t accessp);
102
103 static const char *
104 mptsas_product_type_string(mptsas_t *mpt)
105 {
106 switch (mpt->m_productid & MPI2_FW_HEADER_PID_PROD_MASK) {
107
108 case MPI2_FW_HEADER_PID_PROD_A:
109 return ("A");
110 default:
111 return ("?");
112 }
113 }
114
115 int
116 mptsas_ioc_get_facts(mptsas_t *mpt)
117 {
118 /*
119 * Send get facts messages
120 */
121 if (mptsas_do_dma(mpt, sizeof (MPI2_IOC_FACTS_REQUEST), NULL,
122 mptsas_ioc_do_get_facts)) {
123 return (DDI_FAILURE);
124 }
125
126 /*
127 * Get facts reply messages
128 */
129 if (mptsas_do_dma(mpt, sizeof (MPI2_IOC_FACTS_REPLY), NULL,
130 mptsas_ioc_do_get_facts_reply)) {
131 return (DDI_FAILURE);
132 }
133
134 return (DDI_SUCCESS);
135 }
136
137 static int
138 mptsas_ioc_do_get_facts(mptsas_t *mpt, caddr_t memp, int var,
139 ddi_acc_handle_t accessp)
140 {
141 #ifndef __lock_lint
142 _NOTE(ARGUNUSED(var))
143 #endif
144 pMpi2IOCFactsRequest_t facts;
145 int numbytes;
146
147 bzero(memp, sizeof (*facts));
148 facts = (void *)memp;
149 ddi_put8(accessp, &facts->Function, MPI2_FUNCTION_IOC_FACTS);
150 numbytes = sizeof (*facts);
151
152 /*
153 * Post message via handshake
154 */
155 if (mptsas_send_handshake_msg(mpt, memp, numbytes, accessp)) {
156 return (DDI_FAILURE);
157 }
158
159 return (DDI_SUCCESS);
160 }
161
162 static int
163 mptsas_ioc_do_get_facts_reply(mptsas_t *mpt, caddr_t memp, int var,
164 ddi_acc_handle_t accessp)
165 {
166 #ifndef __lock_lint
167 _NOTE(ARGUNUSED(var))
168 #endif
169
170 pMpi2IOCFactsReply_t factsreply;
171 int numbytes;
172 uint_t iocstatus;
173 char buf[32];
174 uint16_t numReplyFrames;
175 uint16_t queueSize, queueDiff;
176 int simple_sge_main;
177 int simple_sge_next;
178 uint32_t capabilities;
179
180 bzero(memp, sizeof (*factsreply));
181 factsreply = (void *)memp;
182 numbytes = sizeof (*factsreply);
183
184 /*
185 * get ioc facts reply message
186 */
187 if (mptsas_get_handshake_msg(mpt, memp, numbytes, accessp)) {
188 return (DDI_FAILURE);
189 }
190
191 if (iocstatus = ddi_get16(accessp, &factsreply->IOCStatus)) {
192 mptsas_log(mpt, CE_WARN, "mptsas_ioc_do_get_facts_reply: "
193 "IOCStatus=0x%x, IOCLogInfo=0x%x", iocstatus,
194 ddi_get32(accessp, &factsreply->IOCLogInfo));
195 return (DDI_FAILURE);
196 }
197
198 /*
199 * store key values from reply to mpt structure
200 */
201 mpt->m_fwversion = ddi_get32(accessp, &factsreply->FWVersion.Word);
202 mpt->m_productid = ddi_get16(accessp, &factsreply->ProductID);
203
204
205 (void) sprintf(buf, "%u.%u.%u.%u",
206 ddi_get8(accessp, &factsreply->FWVersion.Struct.Major),
207 ddi_get8(accessp, &factsreply->FWVersion.Struct.Minor),
208 ddi_get8(accessp, &factsreply->FWVersion.Struct.Unit),
209 ddi_get8(accessp, &factsreply->FWVersion.Struct.Dev));
210 mptsas_log(mpt, CE_NOTE, "?mpt%d Firmware version v%s (%s)\n",
211 mpt->m_instance, buf, mptsas_product_type_string(mpt));
212 (void) ddi_prop_update_string(DDI_DEV_T_NONE, mpt->m_dip,
213 "firmware-version", buf);
214
215 /*
216 * Set up request info.
217 */
218 mpt->m_max_requests = ddi_get16(accessp,
219 &factsreply->RequestCredit) - 1;
220 mpt->m_req_frame_size = ddi_get16(accessp,
221 &factsreply->IOCRequestFrameSize) * 4;
222
223 /*
224 * Size of reply free queue should be the number of requests
225 * plus some additional for events (32). Make sure number of
226 * reply frames is not a multiple of 16 so that the queue sizes
227 * are calculated correctly later to be a multiple of 16.
228 */
229 mpt->m_reply_frame_size = ddi_get8(accessp,
230 &factsreply->ReplyFrameSize) * 4;
231 numReplyFrames = mpt->m_max_requests + 32;
232 if (!(numReplyFrames % 16)) {
233 numReplyFrames--;
234 }
235 mpt->m_max_replies = numReplyFrames;
236 queueSize = numReplyFrames;
237 queueSize += 16 - (queueSize % 16);
238 mpt->m_free_queue_depth = queueSize;
239
240 /*
241 * Size of reply descriptor post queue should be the number of
242 * request frames + the number of reply frames + 1 and needs to
243 * be a multiple of 16. This size can be no larger than
244 * MaxReplyDescriptorPostQueueDepth from IOCFacts. If the
245 * calculated queue size is larger than allowed, subtract a
246 * multiple of 16 from m_max_requests, m_max_replies, and
247 * m_reply_free_depth.
248 */
249 queueSize = mpt->m_max_requests + numReplyFrames + 1;
250 if (queueSize % 16) {
251 queueSize += 16 - (queueSize % 16);
252 }
253 mpt->m_post_queue_depth = ddi_get16(accessp,
254 &factsreply->MaxReplyDescriptorPostQueueDepth);
255 if (queueSize > mpt->m_post_queue_depth) {
256 queueDiff = queueSize - mpt->m_post_queue_depth;
257 if (queueDiff % 16) {
258 queueDiff += 16 - (queueDiff % 16);
259 }
260 mpt->m_max_requests -= queueDiff;
261 mpt->m_max_replies -= queueDiff;
262 mpt->m_free_queue_depth -= queueDiff;
263 queueSize -= queueDiff;
264 }
265 mpt->m_post_queue_depth = queueSize;
266
267 /*
268 * Set up max chain depth.
269 */
270 mpt->m_max_chain_depth = ddi_get8(accessp,
271 &factsreply->MaxChainDepth);
272 mpt->m_ioc_capabilities = ddi_get32(accessp,
273 &factsreply->IOCCapabilities);
274
275 /*
276 * Calculate max frames per request based on DMA S/G length.
277 */
278 simple_sge_main = MPTSAS_MAX_FRAME_SGES64(mpt) - 1;
279 simple_sge_next = mpt->m_req_frame_size /
280 sizeof (MPI2_SGE_SIMPLE64) - 1;
281
282 mpt->m_max_request_frames = (MPTSAS_MAX_DMA_SEGS -
283 simple_sge_main) / simple_sge_next + 1;
284 if (((MPTSAS_MAX_DMA_SEGS - simple_sge_main) %
285 simple_sge_next) > 1) {
286 mpt->m_max_request_frames++;
287 }
288
289 /*
290 * Check if controller supports FW diag buffers and set flag to enable
291 * each type.
292 */
293 capabilities = ddi_get32(accessp, &factsreply->IOCCapabilities);
294 if (capabilities & MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER) {
295 mpt->m_fw_diag_buffer_list[MPI2_DIAG_BUF_TYPE_TRACE].enabled =
296 TRUE;
297 }
298 if (capabilities & MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER) {
299 mpt->m_fw_diag_buffer_list[MPI2_DIAG_BUF_TYPE_SNAPSHOT].
300 enabled = TRUE;
301 }
302 if (capabilities & MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER) {
303 mpt->m_fw_diag_buffer_list[MPI2_DIAG_BUF_TYPE_EXTENDED].
304 enabled = TRUE;
305 }
306
307 /*
308 * Check if controller supports replaying events when issuing Message
309 * Unit Reset and set flag to enable MUR.
310 */
311 if (capabilities & MPI2_IOCFACTS_CAPABILITY_EVENT_REPLAY) {
312 mpt->m_event_replay = TRUE;
313 }
314
315 /*
316 * Check if controller supports IR.
317 */
318 if (capabilities & MPI2_IOCFACTS_CAPABILITY_INTEGRATED_RAID) {
319 mpt->m_ir_capable = TRUE;
320 }
321
322 return (DDI_SUCCESS);
323 }
324
325 int
326 mptsas_ioc_get_port_facts(mptsas_t *mpt, int port)
327 {
328 /*
329 * Send get port facts message
330 */
331 if (mptsas_do_dma(mpt, sizeof (MPI2_PORT_FACTS_REQUEST), port,
332 mptsas_ioc_do_get_port_facts)) {
333 return (DDI_FAILURE);
334 }
335
336 /*
337 * Get port facts reply message
338 */
339 if (mptsas_do_dma(mpt, sizeof (MPI2_PORT_FACTS_REPLY), port,
340 mptsas_ioc_do_get_port_facts_reply)) {
341 return (DDI_FAILURE);
342 }
343
344 return (DDI_SUCCESS);
345 }
346
347 static int
348 mptsas_ioc_do_get_port_facts(mptsas_t *mpt, caddr_t memp, int var,
349 ddi_acc_handle_t accessp)
350 {
351 pMpi2PortFactsRequest_t facts;
352 int numbytes;
353
354 bzero(memp, sizeof (*facts));
355 facts = (void *)memp;
356 ddi_put8(accessp, &facts->Function, MPI2_FUNCTION_PORT_FACTS);
357 ddi_put8(accessp, &facts->PortNumber, var);
358 numbytes = sizeof (*facts);
359
360 /*
361 * Send port facts message via handshake
362 */
363 if (mptsas_send_handshake_msg(mpt, memp, numbytes, accessp)) {
364 return (DDI_FAILURE);
365 }
366
367 return (DDI_SUCCESS);
368 }
369
370 static int
371 mptsas_ioc_do_get_port_facts_reply(mptsas_t *mpt, caddr_t memp, int var,
372 ddi_acc_handle_t accessp)
373 {
374 #ifndef __lock_lint
375 _NOTE(ARGUNUSED(var))
376 #endif
377 pMpi2PortFactsReply_t factsreply;
378 int numbytes;
379 uint_t iocstatus;
380
381 bzero(memp, sizeof (*factsreply));
382 factsreply = (void *)memp;
383 numbytes = sizeof (*factsreply);
384
385 /*
386 * Get port facts reply message via handshake
387 */
388 if (mptsas_get_handshake_msg(mpt, memp, numbytes, accessp)) {
389 return (DDI_FAILURE);
390 }
391
392 if (iocstatus = ddi_get16(accessp, &factsreply->IOCStatus)) {
393 mptsas_log(mpt, CE_WARN, "mptsas_ioc_do_get_port_facts_reply: "
394 "IOCStatus=0x%x, IOCLogInfo=0x%x", iocstatus,
395 ddi_get32(accessp, &factsreply->IOCLogInfo));
396 return (DDI_FAILURE);
397 }
398
399 return (DDI_SUCCESS);
400 }
401
402 int
403 mptsas_ioc_enable_port(mptsas_t *mpt)
404 {
405 /*
406 * Send enable port message
407 */
408 if (mptsas_do_dma(mpt, sizeof (MPI2_PORT_ENABLE_REQUEST), 0,
409 mptsas_ioc_do_enable_port)) {
410 return (DDI_FAILURE);
411 }
412
413 /*
414 * Get enable port reply message
415 */
416 if (mptsas_do_dma(mpt, sizeof (MPI2_PORT_ENABLE_REPLY), 0,
417 mptsas_ioc_do_enable_port_reply)) {
418 return (DDI_FAILURE);
419 }
420
421 return (DDI_SUCCESS);
422 }
423
424 static int
425 mptsas_ioc_do_enable_port(mptsas_t *mpt, caddr_t memp, int var,
426 ddi_acc_handle_t accessp)
427 {
428 #ifndef __lock_lint
429 _NOTE(ARGUNUSED(var))
430 #endif
431 pMpi2PortEnableRequest_t enable;
432 int numbytes;
433
434 bzero(memp, sizeof (*enable));
435 enable = (void *)memp;
436 ddi_put8(accessp, &enable->Function, MPI2_FUNCTION_PORT_ENABLE);
437 numbytes = sizeof (*enable);
438
439 /*
440 * Send message via handshake
441 */
442 if (mptsas_send_handshake_msg(mpt, memp, numbytes, accessp)) {
443 return (DDI_FAILURE);
444 }
445
446 return (DDI_SUCCESS);
447 }
448
449 static int
450 mptsas_ioc_do_enable_port_reply(mptsas_t *mpt, caddr_t memp, int var,
451 ddi_acc_handle_t accessp)
452 {
453 #ifndef __lock_lint
454 _NOTE(ARGUNUSED(var))
455 #endif
456
457 int numbytes;
458 uint_t iocstatus;
459 pMpi2PortEnableReply_t portreply;
460
461 numbytes = sizeof (MPI2_PORT_ENABLE_REPLY);
462 bzero(memp, numbytes);
463 portreply = (void *)memp;
464
465 /*
466 * Get message via handshake
467 */
468 if (mptsas_get_handshake_msg(mpt, memp, numbytes, accessp)) {
469 return (DDI_FAILURE);
470 }
471
472 if (iocstatus = ddi_get16(accessp, &portreply->IOCStatus)) {
473 mptsas_log(mpt, CE_WARN, "mptsas_ioc_do_enable_port_reply: "
474 "IOCStatus=0x%x, IOCLogInfo=0x%x", iocstatus,
475 ddi_get32(accessp, &portreply->IOCLogInfo));
476 return (DDI_FAILURE);
477 }
478
479 return (DDI_SUCCESS);
480 }
481
482 int
483 mptsas_ioc_enable_event_notification(mptsas_t *mpt)
484 {
485 ASSERT(mutex_owned(&mpt->m_mutex));
486
487 /*
488 * Send enable event notification message
489 */
490 if (mptsas_do_dma(mpt, sizeof (MPI2_EVENT_NOTIFICATION_REQUEST), NULL,
491 mptsas_ioc_do_enable_event_notification)) {
492 return (DDI_FAILURE);
493 }
494
495 /*
496 * Get enable event reply message
497 */
498 if (mptsas_do_dma(mpt, sizeof (MPI2_EVENT_NOTIFICATION_REPLY), NULL,
499 mptsas_ioc_do_enable_event_notification_reply)) {
500 return (DDI_FAILURE);
501 }
502
503 return (DDI_SUCCESS);
504 }
505
506 static int
507 mptsas_ioc_do_enable_event_notification(mptsas_t *mpt, caddr_t memp, int var,
508 ddi_acc_handle_t accessp)
509 {
510 #ifndef __lock_lint
511 _NOTE(ARGUNUSED(var))
512 #endif
513
514 pMpi2EventNotificationRequest_t event;
515 int numbytes;
516
517 bzero(memp, sizeof (*event));
518 event = (void *)memp;
519 ddi_put8(accessp, &event->Function, MPI2_FUNCTION_EVENT_NOTIFICATION);
520 numbytes = sizeof (*event);
521
522 /*
523 * Send message via handshake
524 */
525 if (mptsas_send_handshake_msg(mpt, memp, numbytes, accessp)) {
526 return (DDI_FAILURE);
527 }
528
529 return (DDI_SUCCESS);
530 }
531
532 static int
533 mptsas_ioc_do_enable_event_notification_reply(mptsas_t *mpt, caddr_t memp,
534 int var, ddi_acc_handle_t accessp)
535 {
536 #ifndef __lock_lint
537 _NOTE(ARGUNUSED(var))
538 #endif
539 int numbytes;
540 uint_t iocstatus;
541 pMpi2EventNotificationReply_t eventsreply;
542
543 numbytes = sizeof (MPI2_EVENT_NOTIFICATION_REPLY);
544 bzero(memp, numbytes);
545 eventsreply = (void *)memp;
546
547 /*
548 * Get message via handshake
549 */
550 if (mptsas_get_handshake_msg(mpt, memp, numbytes, accessp)) {
551 return (DDI_FAILURE);
552 }
553
554 if (iocstatus = ddi_get16(accessp, &eventsreply->IOCStatus)) {
555 mptsas_log(mpt, CE_WARN,
556 "mptsas_ioc_do_enable_event_notification_reply: "
557 "IOCStatus=0x%x, IOCLogInfo=0x%x", iocstatus,
558 ddi_get32(accessp, &eventsreply->IOCLogInfo));
559 return (DDI_FAILURE);
560 }
561
562 return (DDI_SUCCESS);
563 }
564
565 int
566 mptsas_ioc_init(mptsas_t *mpt)
567 {
568 /*
569 * Send ioc init message
570 */
571 if (mptsas_do_dma(mpt, sizeof (MPI2_IOC_INIT_REQUEST), NULL,
572 mptsas_do_ioc_init)) {
573 return (DDI_FAILURE);
574 }
575
576 /*
577 * Get ioc init reply message
578 */
579 if (mptsas_do_dma(mpt, sizeof (MPI2_IOC_INIT_REPLY), NULL,
580 mptsas_do_ioc_init_reply)) {
581 return (DDI_FAILURE);
582 }
583
584 return (DDI_SUCCESS);
585 }
586
587 static int
588 mptsas_do_ioc_init(mptsas_t *mpt, caddr_t memp, int var,
589 ddi_acc_handle_t accessp)
590 {
591 #ifndef __lock_lint
592 _NOTE(ARGUNUSED(var))
593 #endif
594
595 pMpi2IOCInitRequest_t init;
596 int numbytes;
597 timespec_t time;
598 uint64_t mSec;
599
600 bzero(memp, sizeof (*init));
601 init = (void *)memp;
602 ddi_put8(accessp, &init->Function, MPI2_FUNCTION_IOC_INIT);
603 ddi_put8(accessp, &init->WhoInit, MPI2_WHOINIT_HOST_DRIVER);
604 ddi_put16(accessp, &init->MsgVersion, MPI2_VERSION);
605 ddi_put16(accessp, &init->HeaderVersion, MPI2_HEADER_VERSION);
606 ddi_put16(accessp, &init->SystemRequestFrameSize,
607 mpt->m_req_frame_size / 4);
608 ddi_put16(accessp, &init->ReplyDescriptorPostQueueDepth,
609 mpt->m_post_queue_depth);
610 ddi_put16(accessp, &init->ReplyFreeQueueDepth,
611 mpt->m_free_queue_depth);
612
613 /*
614 * These addresses are set using the DMA cookie addresses from when the
615 * memory was allocated. Sense buffer hi address should be 0.
616 */
617 ddi_put32(accessp, &init->SenseBufferAddressHigh, 0);
618 ddi_put32(accessp, &init->SystemReplyAddressHigh,
619 (uint32_t)(mpt->m_reply_frame_dma_addr >> 32));
620 ddi_put32(accessp, &init->SystemRequestFrameBaseAddress.High,
621 (uint32_t)(mpt->m_req_frame_dma_addr >> 32));
622 ddi_put32(accessp, &init->SystemRequestFrameBaseAddress.Low,
623 (uint32_t)mpt->m_req_frame_dma_addr);
624 ddi_put32(accessp, &init->ReplyDescriptorPostQueueAddress.High,
625 (uint32_t)(mpt->m_post_queue_dma_addr >> 32));
626 ddi_put32(accessp, &init->ReplyDescriptorPostQueueAddress.Low,
627 (uint32_t)mpt->m_post_queue_dma_addr);
628 ddi_put32(accessp, &init->ReplyFreeQueueAddress.High,
629 (uint32_t)(mpt->m_free_queue_dma_addr >> 32));
630 ddi_put32(accessp, &init->ReplyFreeQueueAddress.Low,
631 (uint32_t)mpt->m_free_queue_dma_addr);
632
633 /*
634 * Fill in the timestamp with the number of milliseconds since midnight
635 * of January 1, 1970 UT (Greenwich Mean Time). Time is returned in
636 * seconds and nanoseconds. Translate both to milliseconds and add
637 * them together to get total milliseconds.
638 */
639 gethrestime(&time);
640 mSec = time.tv_sec * MILLISEC;
641 mSec += (time.tv_nsec / MICROSEC);
642 ddi_put32(accessp, &init->TimeStamp.High, (uint32_t)(mSec >> 32));
643 ddi_put32(accessp, &init->TimeStamp.Low, (uint32_t)mSec);
644
645 numbytes = sizeof (*init);
646
647 /*
648 * Post message via handshake
649 */
650 if (mptsas_send_handshake_msg(mpt, memp, numbytes, accessp)) {
651 return (DDI_FAILURE);
652 }
653
654 return (DDI_SUCCESS);
655 }
656
657 static int
658 mptsas_do_ioc_init_reply(mptsas_t *mpt, caddr_t memp, int var,
659 ddi_acc_handle_t accessp)
660 {
661 #ifndef __lock_lint
662 _NOTE(ARGUNUSED(var))
663 #endif
664
665 pMpi2IOCInitReply_t initreply;
666 int numbytes;
667 uint_t iocstatus;
668
669 numbytes = sizeof (MPI2_IOC_INIT_REPLY);
670 bzero(memp, numbytes);
671 initreply = (void *)memp;
672
673 /*
674 * Get reply message via handshake
675 */
676 if (mptsas_get_handshake_msg(mpt, memp, numbytes, accessp)) {
677 return (DDI_FAILURE);
678 }
679
680 if (iocstatus = ddi_get16(accessp, &initreply->IOCStatus)) {
681 mptsas_log(mpt, CE_WARN, "mptsas_do_ioc_init_reply: "
682 "IOCStatus=0x%x, IOCLogInfo=0x%x", iocstatus,
683 ddi_get32(accessp, &initreply->IOCLogInfo));
684 return (DDI_FAILURE);
685 }
686
687 if ((ddi_get32(mpt->m_datap, &mpt->m_reg->Doorbell)) &
688 MPI2_IOC_STATE_OPERATIONAL) {
689 mptsas_log(mpt, CE_NOTE,
690 "?mpt%d: IOC Operational.\n", mpt->m_instance);
691 } else {
692 return (DDI_FAILURE);
693 }
694
695 return (DDI_SUCCESS);
696 }