1 /*
2 * megaraid_sas.c: source for mega_sas driver
3 *
4 * MegaRAID device driver for SAS controllers
5 * Copyright (c) 2005-2008, LSI Logic Corporation.
6 * All rights reserved.
7 *
8 * Version:
9 * Author:
10 * Rajesh Prabhakaran<Rajesh.Prabhakaran@lsil.com>
11 * Seokmann Ju
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions are met:
15 *
16 * 1. Redistributions of source code must retain the above copyright notice,
17 * this list of conditions and the following disclaimer.
18 *
19 * 2. Redistributions in binary form must reproduce the above copyright notice,
20 * this list of conditions and the following disclaimer in the documentation
21 * and/or other materials provided with the distribution.
22 *
23 * 3. Neither the name of the author nor the names of its contributors may be
24 * used to endorse or promote products derived from this software without
25 * specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
30 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
31 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
32 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
33 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
34 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
35 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
36 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
37 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
38 * DAMAGE.
39 */
40
41 /*
42 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
43 * Use is subject to license terms.
44 * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
45 */
46
47 #include <sys/types.h>
48 #include <sys/param.h>
49 #include <sys/file.h>
50 #include <sys/errno.h>
51 #include <sys/open.h>
52 #include <sys/cred.h>
53 #include <sys/modctl.h>
54 #include <sys/conf.h>
55 #include <sys/devops.h>
56 #include <sys/cmn_err.h>
57 #include <sys/kmem.h>
58 #include <sys/stat.h>
59 #include <sys/mkdev.h>
60 #include <sys/pci.h>
61 #include <sys/scsi/scsi.h>
62 #include <sys/ddi.h>
63 #include <sys/sunddi.h>
64 #include <sys/atomic.h>
65 #include <sys/signal.h>
66
67 #include "megaraid_sas.h"
68
69 /*
70 * FMA header files
71 */
72 #include <sys/ddifm.h>
73 #include <sys/fm/protocol.h>
74 #include <sys/fm/util.h>
75 #include <sys/fm/io/ddi.h>
76
77 /*
78 * Local static data
79 */
80 static void *megasas_state = NULL;
81 static int debug_level_g = CL_ANN;
82
83 #pragma weak scsi_hba_open
84 #pragma weak scsi_hba_close
85 #pragma weak scsi_hba_ioctl
86
87 static ddi_dma_attr_t megasas_generic_dma_attr = {
88 DMA_ATTR_V0, /* dma_attr_version */
89 0, /* low DMA address range */
90 0xFFFFFFFFU, /* high DMA address range */
91 0xFFFFFFFFU, /* DMA counter register */
92 8, /* DMA address alignment */
93 0x07, /* DMA burstsizes */
94 1, /* min DMA size */
95 0xFFFFFFFFU, /* max DMA size */
96 0xFFFFFFFFU, /* segment boundary */
97 MEGASAS_MAX_SGE_CNT, /* dma_attr_sglen */
98 512, /* granularity of device */
99 0 /* bus specific DMA flags */
100 };
101
102 int32_t megasas_max_cap_maxxfer = 0x1000000;
103
104 /*
105 * cb_ops contains base level routines
106 */
107 static struct cb_ops megasas_cb_ops = {
108 megasas_open, /* open */
109 megasas_close, /* close */
110 nodev, /* strategy */
111 nodev, /* print */
112 nodev, /* dump */
113 nodev, /* read */
114 nodev, /* write */
115 megasas_ioctl, /* ioctl */
116 nodev, /* devmap */
117 nodev, /* mmap */
118 nodev, /* segmap */
119 nochpoll, /* poll */
120 nodev, /* cb_prop_op */
121 0, /* streamtab */
122 D_NEW | D_HOTPLUG, /* cb_flag */
123 CB_REV, /* cb_rev */
124 nodev, /* cb_aread */
125 nodev /* cb_awrite */
126 };
127
128 /*
129 * dev_ops contains configuration routines
130 */
131 static struct dev_ops megasas_ops = {
132 DEVO_REV, /* rev, */
133 0, /* refcnt */
134 megasas_getinfo, /* getinfo */
135 nulldev, /* identify */
136 nulldev, /* probe */
137 megasas_attach, /* attach */
138 megasas_detach, /* detach */
139 megasas_reset, /* reset */
140 &megasas_cb_ops, /* char/block ops */
141 NULL, /* bus ops */
142 NULL, /* power */
143 ddi_quiesce_not_supported, /* devo_quiesce */
144 };
145
146 static struct modldrv modldrv = {
147 &mod_driverops, /* module type - driver */
148 MEGASAS_VERSION,
149 &megasas_ops, /* driver ops */
150 };
151
152 static struct modlinkage modlinkage = {
153 MODREV_1, /* ml_rev - must be MODREV_1 */
154 &modldrv, /* ml_linkage */
155 NULL /* end of driver linkage */
156 };
157
158 static struct ddi_device_acc_attr endian_attr = {
159 DDI_DEVICE_ATTR_V1,
160 DDI_STRUCTURE_LE_ACC,
161 DDI_STRICTORDER_ACC,
162 DDI_DEFAULT_ACC
163 };
164
165
166 /*
167 * ************************************************************************** *
168 * *
169 * common entry points - for loadable kernel modules *
170 * *
171 * ************************************************************************** *
172 */
173
174 /*
175 * _init - initialize a loadable module
176 * @void
177 *
178 * The driver should perform any one-time resource allocation or data
179 * initialization during driver loading in _init(). For example, the driver
180 * should initialize any mutexes global to the driver in this routine.
181 * The driver should not, however, use _init() to allocate or initialize
182 * anything that has to do with a particular instance of the device.
183 * Per-instance initialization must be done in attach().
184 */
185 int
186 _init(void)
187 {
188 int ret;
189
190 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
191
192 ret = ddi_soft_state_init(&megasas_state,
193 sizeof (struct megasas_instance), 0);
194
195 if (ret != 0) {
196 con_log(CL_ANN, (CE_WARN, "megaraid: could not init state"));
197 return (ret);
198 }
199
200 if ((ret = scsi_hba_init(&modlinkage)) != 0) {
201 con_log(CL_ANN, (CE_WARN, "megaraid: could not init scsi hba"));
202 ddi_soft_state_fini(&megasas_state);
203 return (ret);
204 }
205
206 ret = mod_install(&modlinkage);
207
208 if (ret != 0) {
209 con_log(CL_ANN, (CE_WARN, "megaraid: mod_install failed"));
210 scsi_hba_fini(&modlinkage);
211 ddi_soft_state_fini(&megasas_state);
212 }
213
214 return (ret);
215 }
216
217 /*
218 * _info - returns information about a loadable module.
219 * @void
220 *
221 * _info() is called to return module information. This is a typical entry
222 * point that does predefined role. It simply calls mod_info().
223 */
224 int
225 _info(struct modinfo *modinfop)
226 {
227 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
228
229 return (mod_info(&modlinkage, modinfop));
230 }
231
232 /*
233 * _fini - prepare a loadable module for unloading
234 * @void
235 *
236 * In _fini(), the driver should release any resources that were allocated in
237 * _init(). The driver must remove itself from the system module list.
238 */
239 int
240 _fini(void)
241 {
242 int ret;
243
244 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
245
246 if ((ret = mod_remove(&modlinkage)) != 0)
247 return (ret);
248
249 scsi_hba_fini(&modlinkage);
250
251 ddi_soft_state_fini(&megasas_state);
252
253 return (ret);
254 }
255
256
257 /*
258 * ************************************************************************** *
259 * *
260 * common entry points - for autoconfiguration *
261 * *
262 * ************************************************************************** *
263 */
264 /*
265 * attach - adds a device to the system as part of initialization
266 * @dip:
267 * @cmd:
268 *
269 * The kernel calls a driver's attach() entry point to attach an instance of
270 * a device (for MegaRAID, it is instance of a controller) or to resume
271 * operation for an instance of a device that has been suspended or has been
272 * shut down by the power management framework
273 * The attach() entry point typically includes the following types of
274 * processing:
275 * - allocate a soft-state structure for the device instance (for MegaRAID,
276 * controller instance)
277 * - initialize per-instance mutexes
278 * - initialize condition variables
279 * - register the device's interrupts (for MegaRAID, controller's interrupts)
280 * - map the registers and memory of the device instance (for MegaRAID,
281 * controller instance)
282 * - create minor device nodes for the device instance (for MegaRAID,
283 * controller instance)
284 * - report that the device instance (for MegaRAID, controller instance) has
285 * attached
286 */
287 static int
288 megasas_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
289 {
290 int instance_no;
291 int nregs;
292 uint8_t added_isr_f = 0;
293 uint8_t added_soft_isr_f = 0;
294 uint8_t create_devctl_node_f = 0;
295 uint8_t create_scsi_node_f = 0;
296 uint8_t create_ioc_node_f = 0;
297 uint8_t tran_alloc_f = 0;
298 uint8_t irq;
299 uint16_t vendor_id;
300 uint16_t device_id;
301 uint16_t subsysvid;
302 uint16_t subsysid;
303 uint16_t command;
304
305 scsi_hba_tran_t *tran;
306 ddi_dma_attr_t tran_dma_attr;
307 struct megasas_instance *instance;
308
309 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
310
311 /* CONSTCOND */
312 ASSERT(NO_COMPETING_THREADS);
313
314 instance_no = ddi_get_instance(dip);
315
316 /*
317 * Since we know that some instantiations of this device can be
318 * plugged into slave-only SBus slots, check to see whether this is
319 * one such.
320 */
321 if (ddi_slaveonly(dip) == DDI_SUCCESS) {
322 con_log(CL_ANN, (CE_WARN,
323 "mega%d: Device in slave-only slot, unused", instance_no));
324 return (DDI_FAILURE);
325 }
326
327 switch (cmd) {
328 case DDI_ATTACH:
329 con_log(CL_DLEVEL1, (CE_NOTE, "megasas: DDI_ATTACH"));
330 /* allocate the soft state for the instance */
331 if (ddi_soft_state_zalloc(megasas_state, instance_no)
332 != DDI_SUCCESS) {
333 con_log(CL_ANN, (CE_WARN,
334 "mega%d: Failed to allocate soft state",
335 instance_no));
336
337 return (DDI_FAILURE);
338 }
339
340 instance = (struct megasas_instance *)ddi_get_soft_state
341 (megasas_state, instance_no);
342
343 if (instance == NULL) {
344 con_log(CL_ANN, (CE_WARN,
345 "mega%d: Bad soft state", instance_no));
346
347 ddi_soft_state_free(megasas_state, instance_no);
348
349 return (DDI_FAILURE);
350 }
351
352 bzero((caddr_t)instance,
353 sizeof (struct megasas_instance));
354
355 instance->func_ptr = kmem_zalloc(
356 sizeof (struct megasas_func_ptr), KM_SLEEP);
357 ASSERT(instance->func_ptr);
358
359 /* Setup the PCI configuration space handles */
360 if (pci_config_setup(dip, &instance->pci_handle) !=
361 DDI_SUCCESS) {
362 con_log(CL_ANN, (CE_WARN,
363 "mega%d: pci config setup failed ",
364 instance_no));
365
366 kmem_free(instance->func_ptr,
367 sizeof (struct megasas_func_ptr));
368 ddi_soft_state_free(megasas_state, instance_no);
369
370 return (DDI_FAILURE);
371 }
372
373 if (ddi_dev_nregs(dip, &nregs) != DDI_SUCCESS) {
374 con_log(CL_ANN, (CE_WARN,
375 "megaraid: failed to get registers."));
376
377 pci_config_teardown(&instance->pci_handle);
378 kmem_free(instance->func_ptr,
379 sizeof (struct megasas_func_ptr));
380 ddi_soft_state_free(megasas_state, instance_no);
381
382 return (DDI_FAILURE);
383 }
384
385 vendor_id = pci_config_get16(instance->pci_handle,
386 PCI_CONF_VENID);
387 device_id = pci_config_get16(instance->pci_handle,
388 PCI_CONF_DEVID);
389
390 subsysvid = pci_config_get16(instance->pci_handle,
391 PCI_CONF_SUBVENID);
392 subsysid = pci_config_get16(instance->pci_handle,
393 PCI_CONF_SUBSYSID);
394
395 pci_config_put16(instance->pci_handle, PCI_CONF_COMM,
396 (pci_config_get16(instance->pci_handle,
397 PCI_CONF_COMM) | PCI_COMM_ME));
398 irq = pci_config_get8(instance->pci_handle,
399 PCI_CONF_ILINE);
400
401 con_log(CL_DLEVEL1, (CE_CONT, "megasas%d: "
402 "0x%x:0x%x 0x%x:0x%x, irq:%d drv-ver:%s\n",
403 instance_no, vendor_id, device_id, subsysvid,
404 subsysid, irq, MEGASAS_VERSION));
405
406 /* enable bus-mastering */
407 command = pci_config_get16(instance->pci_handle,
408 PCI_CONF_COMM);
409
410 if (!(command & PCI_COMM_ME)) {
411 command |= PCI_COMM_ME;
412
413 pci_config_put16(instance->pci_handle,
414 PCI_CONF_COMM, command);
415
416 con_log(CL_ANN, (CE_CONT, "megaraid%d: "
417 "enable bus-mastering\n", instance_no));
418 } else {
419 con_log(CL_DLEVEL1, (CE_CONT, "megaraid%d: "
420 "bus-mastering already set\n", instance_no));
421 }
422
423 /* initialize function pointers */
424 if ((device_id == PCI_DEVICE_ID_LSI_1078) ||
425 (device_id == PCI_DEVICE_ID_LSI_1078DE)) {
426 con_log(CL_DLEVEL1, (CE_CONT, "megasas%d: "
427 "1078R/DE detected\n", instance_no));
428 instance->func_ptr->read_fw_status_reg =
429 read_fw_status_reg_ppc;
430 instance->func_ptr->issue_cmd = issue_cmd_ppc;
431 instance->func_ptr->issue_cmd_in_sync_mode =
432 issue_cmd_in_sync_mode_ppc;
433 instance->func_ptr->issue_cmd_in_poll_mode =
434 issue_cmd_in_poll_mode_ppc;
435 instance->func_ptr->enable_intr =
436 enable_intr_ppc;
437 instance->func_ptr->disable_intr =
438 disable_intr_ppc;
439 instance->func_ptr->intr_ack = intr_ack_ppc;
440 } else {
441 con_log(CL_DLEVEL1, (CE_CONT, "megasas%d: "
442 "1064/8R detected\n", instance_no));
443 instance->func_ptr->read_fw_status_reg =
444 read_fw_status_reg_xscale;
445 instance->func_ptr->issue_cmd =
446 issue_cmd_xscale;
447 instance->func_ptr->issue_cmd_in_sync_mode =
448 issue_cmd_in_sync_mode_xscale;
449 instance->func_ptr->issue_cmd_in_poll_mode =
450 issue_cmd_in_poll_mode_xscale;
451 instance->func_ptr->enable_intr =
452 enable_intr_xscale;
453 instance->func_ptr->disable_intr =
454 disable_intr_xscale;
455 instance->func_ptr->intr_ack =
456 intr_ack_xscale;
457 }
458
459 instance->baseaddress = pci_config_get32(
460 instance->pci_handle, PCI_CONF_BASE0);
461 instance->baseaddress &= 0x0fffc;
462
463 instance->dip = dip;
464 instance->vendor_id = vendor_id;
465 instance->device_id = device_id;
466 instance->subsysvid = subsysvid;
467 instance->subsysid = subsysid;
468
469 /* Initialize FMA */
470 instance->fm_capabilities = ddi_prop_get_int(
471 DDI_DEV_T_ANY, instance->dip, DDI_PROP_DONTPASS,
472 "fm-capable", DDI_FM_EREPORT_CAPABLE |
473 DDI_FM_ACCCHK_CAPABLE | DDI_FM_DMACHK_CAPABLE
474 | DDI_FM_ERRCB_CAPABLE);
475
476 megasas_fm_init(instance);
477
478 /* setup the mfi based low level driver */
479 if (init_mfi(instance) != DDI_SUCCESS) {
480 con_log(CL_ANN, (CE_WARN, "megaraid: "
481 "could not initialize the low level driver"));
482
483 goto fail_attach;
484 }
485
486 /*
487 * Allocate the interrupt blocking cookie.
488 * It represents the information the framework
489 * needs to block interrupts. This cookie will
490 * be used by the locks shared accross our ISR.
491 * These locks must be initialized before we
492 * register our ISR.
493 * ddi_add_intr(9F)
494 */
495 if (ddi_get_iblock_cookie(dip, 0,
496 &instance->iblock_cookie) != DDI_SUCCESS) {
497
498 goto fail_attach;
499 }
500
501 if (ddi_get_soft_iblock_cookie(dip, DDI_SOFTINT_HIGH,
502 &instance->soft_iblock_cookie) != DDI_SUCCESS) {
503
504 goto fail_attach;
505 }
506
507 /*
508 * Initialize the driver mutexes common to
509 * normal/high level isr
510 */
511 if (ddi_intr_hilevel(dip, 0)) {
512 instance->isr_level = HIGH_LEVEL_INTR;
513 mutex_init(&instance->cmd_pool_mtx,
514 "cmd_pool_mtx", MUTEX_DRIVER,
515 instance->soft_iblock_cookie);
516 mutex_init(&instance->cmd_pend_mtx,
517 "cmd_pend_mtx", MUTEX_DRIVER,
518 instance->soft_iblock_cookie);
519 } else {
520 /*
521 * Initialize the driver mutexes
522 * specific to soft-isr
523 */
524 instance->isr_level = NORMAL_LEVEL_INTR;
525 mutex_init(&instance->cmd_pool_mtx,
526 "cmd_pool_mtx", MUTEX_DRIVER,
527 instance->iblock_cookie);
528 mutex_init(&instance->cmd_pend_mtx,
529 "cmd_pend_mtx", MUTEX_DRIVER,
530 instance->iblock_cookie);
531 }
532
533 mutex_init(&instance->completed_pool_mtx,
534 "completed_pool_mtx", MUTEX_DRIVER,
535 instance->iblock_cookie);
536 mutex_init(&instance->int_cmd_mtx, "int_cmd_mtx",
537 MUTEX_DRIVER, instance->iblock_cookie);
538 mutex_init(&instance->aen_cmd_mtx, "aen_cmd_mtx",
539 MUTEX_DRIVER, instance->iblock_cookie);
540 mutex_init(&instance->abort_cmd_mtx, "abort_cmd_mtx",
541 MUTEX_DRIVER, instance->iblock_cookie);
542
543 cv_init(&instance->int_cmd_cv, NULL, CV_DRIVER, NULL);
544 cv_init(&instance->abort_cmd_cv, NULL, CV_DRIVER, NULL);
545
546 INIT_LIST_HEAD(&instance->completed_pool_list);
547
548 /* Register our isr. */
549 if (ddi_add_intr(dip, 0, NULL, NULL, megasas_isr,
550 (caddr_t)instance) != DDI_SUCCESS) {
551 con_log(CL_ANN, (CE_WARN,
552 " ISR did not register"));
553
554 goto fail_attach;
555 }
556
557 added_isr_f = 1;
558
559 /* Register our soft-isr for highlevel interrupts. */
560 if (instance->isr_level == HIGH_LEVEL_INTR) {
561 if (ddi_add_softintr(dip, DDI_SOFTINT_HIGH,
562 &instance->soft_intr_id, NULL, NULL,
563 megasas_softintr, (caddr_t)instance) !=
564 DDI_SUCCESS) {
565 con_log(CL_ANN, (CE_WARN,
566 " Software ISR did not register"));
567
568 goto fail_attach;
569 }
570
571 added_soft_isr_f = 1;
572 }
573
574 /* Allocate a transport structure */
575 tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
576
577 if (tran == NULL) {
578 con_log(CL_ANN, (CE_WARN,
579 "scsi_hba_tran_alloc failed"));
580 goto fail_attach;
581 }
582
583 tran_alloc_f = 1;
584
585 instance->tran = tran;
586
587 tran->tran_hba_private = instance;
588 tran->tran_tgt_private = NULL;
589 tran->tran_tgt_init = megasas_tran_tgt_init;
590 tran->tran_tgt_probe = scsi_hba_probe;
591 tran->tran_tgt_free = (void (*)())NULL;
592 tran->tran_init_pkt = megasas_tran_init_pkt;
593 tran->tran_start = megasas_tran_start;
594 tran->tran_abort = megasas_tran_abort;
595 tran->tran_reset = megasas_tran_reset;
596 tran->tran_bus_reset = megasas_tran_bus_reset;
597 tran->tran_getcap = megasas_tran_getcap;
598 tran->tran_setcap = megasas_tran_setcap;
599 tran->tran_destroy_pkt = megasas_tran_destroy_pkt;
600 tran->tran_dmafree = megasas_tran_dmafree;
601 tran->tran_sync_pkt = megasas_tran_sync_pkt;
602 tran->tran_reset_notify = NULL;
603 tran->tran_quiesce = megasas_tran_quiesce;
604 tran->tran_unquiesce = megasas_tran_unquiesce;
605
606 tran_dma_attr = megasas_generic_dma_attr;
607 tran_dma_attr.dma_attr_sgllen = instance->max_num_sge;
608
609 /* Attach this instance of the hba */
610 if (scsi_hba_attach_setup(dip, &tran_dma_attr, tran, 0)
611 != DDI_SUCCESS) {
612 con_log(CL_ANN, (CE_WARN,
613 "scsi_hba_attach failed\n"));
614
615 goto fail_attach;
616 }
617
618 /* create devctl node for cfgadm command */
619 if (ddi_create_minor_node(dip, "devctl",
620 S_IFCHR, INST2DEVCTL(instance_no),
621 DDI_NT_SCSI_NEXUS, 0) == DDI_FAILURE) {
622 con_log(CL_ANN, (CE_WARN,
623 "megaraid: failed to create devctl node."));
624
625 goto fail_attach;
626 }
627
628 create_devctl_node_f = 1;
629
630 /* create scsi node for cfgadm command */
631 if (ddi_create_minor_node(dip, "scsi", S_IFCHR,
632 INST2SCSI(instance_no),
633 DDI_NT_SCSI_ATTACHMENT_POINT, 0) ==
634 DDI_FAILURE) {
635 con_log(CL_ANN, (CE_WARN,
636 "megaraid: failed to create scsi node."));
637
638 goto fail_attach;
639 }
640
641 create_scsi_node_f = 1;
642
643 (void) sprintf(instance->iocnode, "%d:lsirdctl",
644 instance_no);
645
646 /*
647 * Create a node for applications
648 * for issuing ioctl to the driver.
649 */
650 if (ddi_create_minor_node(dip, instance->iocnode,
651 S_IFCHR, INST2LSIRDCTL(instance_no),
652 DDI_PSEUDO, 0) == DDI_FAILURE) {
653 con_log(CL_ANN, (CE_WARN,
654 "megaraid: failed to create ioctl node."));
655
656 goto fail_attach;
657 }
658
659 create_ioc_node_f = 1;
660
661 /* enable interrupt */
662 instance->func_ptr->enable_intr(instance);
663
664 /* initiate AEN */
665 if (start_mfi_aen(instance)) {
666 con_log(CL_ANN, (CE_WARN,
667 "megaraid: failed to initiate AEN."));
668 goto fail_initiate_aen;
669 }
670
671 con_log(CL_DLEVEL1, (CE_NOTE,
672 "AEN started for instance %d.", instance_no));
673
674 /* Finally! We are on the air. */
675 ddi_report_dev(dip);
676
677 if (megasas_check_acc_handle(instance->regmap_handle) !=
678 DDI_SUCCESS) {
679 goto fail_attach;
680 }
681 if (megasas_check_acc_handle(instance->pci_handle) !=
682 DDI_SUCCESS) {
683 goto fail_attach;
684 }
685 break;
686 case DDI_PM_RESUME:
687 con_log(CL_ANN, (CE_NOTE,
688 "megasas: DDI_PM_RESUME"));
689 break;
690 case DDI_RESUME:
691 con_log(CL_ANN, (CE_NOTE,
692 "megasas: DDI_RESUME"));
693 break;
694 default:
695 con_log(CL_ANN, (CE_WARN,
696 "megasas: invalid attach cmd=%x", cmd));
697 return (DDI_FAILURE);
698 }
699
700 return (DDI_SUCCESS);
701
702 fail_initiate_aen:
703 fail_attach:
704 if (create_devctl_node_f) {
705 ddi_remove_minor_node(dip, "devctl");
706 }
707
708 if (create_scsi_node_f) {
709 ddi_remove_minor_node(dip, "scsi");
710 }
711
712 if (create_ioc_node_f) {
713 ddi_remove_minor_node(dip, instance->iocnode);
714 }
715
716 if (tran_alloc_f) {
717 scsi_hba_tran_free(tran);
718 }
719
720
721 if (added_soft_isr_f) {
722 ddi_remove_softintr(instance->soft_intr_id);
723 }
724
725 if (added_isr_f) {
726 ddi_remove_intr(dip, 0, instance->iblock_cookie);
727 }
728
729 megasas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
730 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
731
732 megasas_fm_fini(instance);
733
734 pci_config_teardown(&instance->pci_handle);
735
736 ddi_soft_state_free(megasas_state, instance_no);
737
738 con_log(CL_ANN, (CE_NOTE,
739 "megasas: return failure from mega_attach\n"));
740
741 return (DDI_FAILURE);
742 }
743
744 /*
745 * getinfo - gets device information
746 * @dip:
747 * @cmd:
748 * @arg:
749 * @resultp:
750 *
751 * The system calls getinfo() to obtain configuration information that only
752 * the driver knows. The mapping of minor numbers to device instance is
753 * entirely under the control of the driver. The system sometimes needs to ask
754 * the driver which device a particular dev_t represents.
755 * Given the device number return the devinfo pointer from the scsi_device
756 * structure.
757 */
758 /*ARGSUSED*/
759 static int
760 megasas_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
761 {
762 int rval;
763 int megasas_minor = getminor((dev_t)arg);
764
765 struct megasas_instance *instance;
766
767 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
768
769 switch (cmd) {
770 case DDI_INFO_DEVT2DEVINFO:
771 instance = (struct megasas_instance *)
772 ddi_get_soft_state(megasas_state,
773 MINOR2INST(megasas_minor));
774
775 if (instance == NULL) {
776 *resultp = NULL;
777 rval = DDI_FAILURE;
778 } else {
779 *resultp = instance->dip;
780 rval = DDI_SUCCESS;
781 }
782 break;
783 case DDI_INFO_DEVT2INSTANCE:
784 *resultp = (void *)instance;
785 rval = DDI_SUCCESS;
786 break;
787 default:
788 *resultp = NULL;
789 rval = DDI_FAILURE;
790 }
791
792 return (rval);
793 }
794
795 /*
796 * detach - detaches a device from the system
797 * @dip: pointer to the device's dev_info structure
798 * @cmd: type of detach
799 *
800 * A driver's detach() entry point is called to detach an instance of a device
801 * that is bound to the driver. The entry point is called with the instance of
802 * the device node to be detached and with DDI_DETACH, which is specified as
803 * the cmd argument to the entry point.
804 * This routine is called during driver unload. We free all the allocated
805 * resources and call the corresponding LLD so that it can also release all
806 * its resources.
807 */
808 static int
809 megasas_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
810 {
811 int instance_no;
812
813 struct megasas_instance *instance;
814
815 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
816
817 /* CONSTCOND */
818 ASSERT(NO_COMPETING_THREADS);
819
820 instance_no = ddi_get_instance(dip);
821
822 instance = (struct megasas_instance *)ddi_get_soft_state(megasas_state,
823 instance_no);
824
825 if (!instance) {
826 con_log(CL_ANN, (CE_WARN,
827 "megasas:%d could not get instance in detach",
828 instance_no));
829
830 return (DDI_FAILURE);
831 }
832
833 con_log(CL_ANN, (CE_NOTE,
834 "megasas%d: detaching device 0x%4x:0x%4x:0x%4x:0x%4x\n",
835 instance_no, instance->vendor_id, instance->device_id,
836 instance->subsysvid, instance->subsysid));
837
838 switch (cmd) {
839 case DDI_DETACH:
840 con_log(CL_ANN, (CE_NOTE,
841 "megasas_detach: DDI_DETACH\n"));
842
843 if (scsi_hba_detach(dip) != DDI_SUCCESS) {
844 con_log(CL_ANN, (CE_WARN,
845 "megasas:%d failed to detach",
846 instance_no));
847
848 return (DDI_FAILURE);
849 }
850
851 scsi_hba_tran_free(instance->tran);
852
853 if (abort_aen_cmd(instance, instance->aen_cmd)) {
854 con_log(CL_ANN, (CE_WARN, "megasas_detach: "
855 "failed to abort prevous AEN command\n"));
856
857 return (DDI_FAILURE);
858 }
859
860 instance->func_ptr->disable_intr(instance);
861
862 if (instance->isr_level == HIGH_LEVEL_INTR) {
863 ddi_remove_softintr(instance->soft_intr_id);
864 }
865
866 ddi_remove_intr(dip, 0, instance->iblock_cookie);
867
868 free_space_for_mfi(instance);
869
870 megasas_fm_fini(instance);
871
872 pci_config_teardown(&instance->pci_handle);
873
874 kmem_free(instance->func_ptr,
875 sizeof (struct megasas_func_ptr));
876
877 ddi_soft_state_free(megasas_state, instance_no);
878 break;
879 case DDI_PM_SUSPEND:
880 con_log(CL_ANN, (CE_NOTE,
881 "megasas_detach: DDI_PM_SUSPEND\n"));
882
883 break;
884 case DDI_SUSPEND:
885 con_log(CL_ANN, (CE_NOTE,
886 "megasas_detach: DDI_SUSPEND\n"));
887
888 break;
889 default:
890 con_log(CL_ANN, (CE_WARN,
891 "invalid detach command:0x%x", cmd));
892 return (DDI_FAILURE);
893 }
894
895 return (DDI_SUCCESS);
896 }
897
898 /*
899 * ************************************************************************** *
900 * *
901 * common entry points - for character driver types *
902 * *
903 * ************************************************************************** *
904 */
905 /*
906 * open - gets access to a device
907 * @dev:
908 * @openflags:
909 * @otyp:
910 * @credp:
911 *
912 * Access to a device by one or more application programs is controlled
913 * through the open() and close() entry points. The primary function of
914 * open() is to verify that the open request is allowed.
915 */
916 static int
917 megasas_open(dev_t *dev, int openflags, int otyp, cred_t *credp)
918 {
919 int rval = 0;
920
921 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
922
923 /* Check root permissions */
924 if (drv_priv(credp) != 0) {
925 con_log(CL_ANN, (CE_WARN,
926 "megaraid: Non-root ioctl access tried!"));
927 return (EPERM);
928 }
929
930 /* Verify we are being opened as a character device */
931 if (otyp != OTYP_CHR) {
932 con_log(CL_ANN, (CE_WARN,
933 "megaraid: ioctl node must be a char node\n"));
934 return (EINVAL);
935 }
936
937 if (ddi_get_soft_state(megasas_state, MINOR2INST(getminor(*dev)))
938 == NULL) {
939 return (ENXIO);
940 }
941
942 if (scsi_hba_open) {
943 rval = scsi_hba_open(dev, openflags, otyp, credp);
944 }
945
946 return (rval);
947 }
948
949 /*
950 * close - gives up access to a device
951 * @dev:
952 * @openflags:
953 * @otyp:
954 * @credp:
955 *
956 * close() should perform any cleanup necessary to finish using the minor
957 * device, and prepare the device (and driver) to be opened again.
958 */
959 static int
960 megasas_close(dev_t dev, int openflags, int otyp, cred_t *credp)
961 {
962 int rval = 0;
963
964 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
965
966 /* no need for locks! */
967
968 if (scsi_hba_close) {
969 rval = scsi_hba_close(dev, openflags, otyp, credp);
970 }
971
972 return (rval);
973 }
974
975 /*
976 * ioctl - performs a range of I/O commands for character drivers
977 * @dev:
978 * @cmd:
979 * @arg:
980 * @mode:
981 * @credp:
982 * @rvalp:
983 *
984 * ioctl() routine must make sure that user data is copied into or out of the
985 * kernel address space explicitly using copyin(), copyout(), ddi_copyin(),
986 * and ddi_copyout(), as appropriate.
987 * This is a wrapper routine to serialize access to the actual ioctl routine.
988 * ioctl() should return 0 on success, or the appropriate error number. The
989 * driver may also set the value returned to the calling process through rvalp.
990 */
991 static int
992 megasas_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
993 int *rvalp)
994 {
995 int rval = 0;
996
997 struct megasas_instance *instance;
998 struct megasas_ioctl ioctl;
999 struct megasas_aen aen;
1000
1001 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1002
1003 instance = ddi_get_soft_state(megasas_state, MINOR2INST(getminor(dev)));
1004
1005 if (instance == NULL) {
1006 /* invalid minor number */
1007 con_log(CL_ANN, (CE_WARN, "megaraid: adapter not found."));
1008 return (ENXIO);
1009 }
1010
1011 switch ((uint_t)cmd) {
1012 case MEGASAS_IOCTL_FIRMWARE:
1013 if (ddi_copyin((void *) arg, &ioctl,
1014 sizeof (struct megasas_ioctl), mode)) {
1015 con_log(CL_ANN, (CE_WARN, "megasas_ioctl: "
1016 "ERROR IOCTL copyin"));
1017 return (EFAULT);
1018 }
1019
1020 if (ioctl.control_code == MR_DRIVER_IOCTL_COMMON) {
1021 rval = handle_drv_ioctl(instance, &ioctl, mode);
1022 } else {
1023 rval = handle_mfi_ioctl(instance, &ioctl, mode);
1024 }
1025
1026 if (ddi_copyout((void *) &ioctl, (void *)arg,
1027 (sizeof (struct megasas_ioctl) - 1), mode)) {
1028 con_log(CL_ANN, (CE_WARN,
1029 "megasas_ioctl: copy_to_user failed\n"));
1030 rval = 1;
1031 }
1032
1033 break;
1034 case MEGASAS_IOCTL_AEN:
1035 if (ddi_copyin((void *) arg, &aen,
1036 sizeof (struct megasas_aen), mode)) {
1037 con_log(CL_ANN, (CE_WARN,
1038 "megasas_ioctl: ERROR AEN copyin"));
1039 return (EFAULT);
1040 }
1041
1042 rval = handle_mfi_aen(instance, &aen);
1043
1044 if (ddi_copyout((void *) &aen, (void *)arg,
1045 sizeof (struct megasas_aen), mode)) {
1046 con_log(CL_ANN, (CE_WARN,
1047 "megasas_ioctl: copy_to_user failed\n"));
1048 rval = 1;
1049 }
1050
1051 break;
1052 default:
1053 rval = scsi_hba_ioctl(dev, cmd, arg,
1054 mode, credp, rvalp);
1055
1056 con_log(CL_DLEVEL1, (CE_NOTE, "megasas_ioctl: "
1057 "scsi_hba_ioctl called, ret = %x.", rval));
1058 }
1059
1060 return (rval);
1061 }
1062
1063 /*
1064 * ************************************************************************** *
1065 * *
1066 * common entry points - for block driver types *
1067 * *
1068 * ************************************************************************** *
1069 */
1070 /*
1071 * reset - TBD
1072 * @dip:
1073 * @cmd:
1074 *
1075 * TBD
1076 */
1077 /*ARGSUSED*/
1078 static int
1079 megasas_reset(dev_info_t *dip, ddi_reset_cmd_t cmd)
1080 {
1081 int instance_no;
1082
1083 struct megasas_instance *instance;
1084
1085 instance_no = ddi_get_instance(dip);
1086 instance = (struct megasas_instance *)ddi_get_soft_state
1087 (megasas_state, instance_no);
1088
1089 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1090
1091 if (!instance) {
1092 con_log(CL_ANN, (CE_WARN,
1093 "megaraid:%d could not get adapter in reset",
1094 instance_no));
1095 return (DDI_FAILURE);
1096 }
1097
1098 con_log(CL_ANN, (CE_NOTE, "flushing cache for instance %d ..",
1099 instance_no));
1100
1101 flush_cache(instance);
1102
1103 return (DDI_SUCCESS);
1104 }
1105
1106
1107 /*
1108 * ************************************************************************** *
1109 * *
1110 * entry points (SCSI HBA) *
1111 * *
1112 * ************************************************************************** *
1113 */
1114 /*
1115 * tran_tgt_init - initialize a target device instance
1116 * @hba_dip:
1117 * @tgt_dip:
1118 * @tran:
1119 * @sd:
1120 *
1121 * The tran_tgt_init() entry point enables the HBA to allocate and initialize
1122 * any per-target resources. tran_tgt_init() also enables the HBA to qualify
1123 * the device's address as valid and supportable for that particular HBA.
1124 * By returning DDI_FAILURE, the instance of the target driver for that device
1125 * is not probed or attached.
1126 */
1127 /*ARGSUSED*/
1128 static int
1129 megasas_tran_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
1130 scsi_hba_tran_t *tran, struct scsi_device *sd)
1131 {
1132 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1133
1134 return (DDI_SUCCESS);
1135 }
1136
1137 /*
1138 * tran_init_pkt - allocate & initialize a scsi_pkt structure
1139 * @ap:
1140 * @pkt:
1141 * @bp:
1142 * @cmdlen:
1143 * @statuslen:
1144 * @tgtlen:
1145 * @flags:
1146 * @callback:
1147 *
1148 * The tran_init_pkt() entry point allocates and initializes a scsi_pkt
1149 * structure and DMA resources for a target driver request. The
1150 * tran_init_pkt() entry point is called when the target driver calls the
1151 * SCSA function scsi_init_pkt(). Each call of the tran_init_pkt() entry point
1152 * is a request to perform one or more of three possible services:
1153 * - allocation and initialization of a scsi_pkt structure
1154 * - allocation of DMA resources for data transfer
1155 * - reallocation of DMA resources for the next portion of the data transfer
1156 */
1157 static struct scsi_pkt *
1158 megasas_tran_init_pkt(struct scsi_address *ap, register struct scsi_pkt *pkt,
1159 struct buf *bp, int cmdlen, int statuslen, int tgtlen,
1160 int flags, int (*callback)(), caddr_t arg)
1161 {
1162 struct scsa_cmd *acmd;
1163 struct megasas_instance *instance;
1164 struct scsi_pkt *new_pkt;
1165
1166 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1167
1168 instance = ADDR2MEGA(ap);
1169
1170 /* step #1 : pkt allocation */
1171 if (pkt == NULL) {
1172 pkt = scsi_hba_pkt_alloc(instance->dip, ap, cmdlen, statuslen,
1173 tgtlen, sizeof (struct scsa_cmd), callback, arg);
1174 if (pkt == NULL) {
1175 return (NULL);
1176 }
1177
1178 acmd = PKT2CMD(pkt);
1179
1180 /*
1181 * Initialize the new pkt - we redundantly initialize
1182 * all the fields for illustrative purposes.
1183 */
1184 acmd->cmd_pkt = pkt;
1185 acmd->cmd_flags = 0;
1186 acmd->cmd_scblen = statuslen;
1187 acmd->cmd_cdblen = cmdlen;
1188 acmd->cmd_dmahandle = NULL;
1189 acmd->cmd_ncookies = 0;
1190 acmd->cmd_cookie = 0;
1191 acmd->cmd_cookiecnt = 0;
1192 acmd->cmd_nwin = 0;
1193
1194 pkt->pkt_address = *ap;
1195 pkt->pkt_comp = (void (*)())NULL;
1196 pkt->pkt_flags = 0;
1197 pkt->pkt_time = 0;
1198 pkt->pkt_resid = 0;
1199 pkt->pkt_state = 0;
1200 pkt->pkt_statistics = 0;
1201 pkt->pkt_reason = 0;
1202 new_pkt = pkt;
1203 } else {
1204 acmd = PKT2CMD(pkt);
1205 new_pkt = NULL;
1206 }
1207
1208 /* step #2 : dma allocation/move */
1209 if (bp && bp->b_bcount != 0) {
1210 if (acmd->cmd_dmahandle == NULL) {
1211 if (megasas_dma_alloc(instance, pkt, bp, flags,
1212 callback) == -1) {
1213 if (new_pkt) {
1214 scsi_hba_pkt_free(ap, new_pkt);
1215 }
1216
1217 return ((struct scsi_pkt *)NULL);
1218 }
1219 } else {
1220 if (megasas_dma_move(instance, pkt, bp) == -1) {
1221 return ((struct scsi_pkt *)NULL);
1222 }
1223 }
1224 }
1225
1226 return (pkt);
1227 }
1228
1229 /*
1230 * tran_start - transport a SCSI command to the addressed target
1231 * @ap:
1232 * @pkt:
1233 *
1234 * The tran_start() entry point for a SCSI HBA driver is called to transport a
1235 * SCSI command to the addressed target. The SCSI command is described
1236 * entirely within the scsi_pkt structure, which the target driver allocated
1237 * through the HBA driver's tran_init_pkt() entry point. If the command
1238 * involves a data transfer, DMA resources must also have been allocated for
1239 * the scsi_pkt structure.
1240 *
1241 * Return Values :
1242 * TRAN_BUSY - request queue is full, no more free scbs
1243 * TRAN_ACCEPT - pkt has been submitted to the instance
1244 */
1245 static int
1246 megasas_tran_start(struct scsi_address *ap, register struct scsi_pkt *pkt)
1247 {
1248 uchar_t cmd_done = 0;
1249
1250 struct megasas_instance *instance = ADDR2MEGA(ap);
1251 struct megasas_cmd *cmd;
1252
1253 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d:SCSI CDB[0]=0x%x",
1254 __func__, __LINE__, pkt->pkt_cdbp[0]));
1255
1256 pkt->pkt_reason = CMD_CMPLT;
1257 *pkt->pkt_scbp = STATUS_GOOD; /* clear arq scsi_status */
1258
1259 cmd = build_cmd(instance, ap, pkt, &cmd_done);
1260
1261 /*
1262 * Check if the command is already completed by the mega_build_cmd()
1263 * routine. In which case the busy_flag would be clear and scb will be
1264 * NULL and appropriate reason provided in pkt_reason field
1265 */
1266 if (cmd_done) {
1267 if ((pkt->pkt_flags & FLAG_NOINTR) == 0) {
1268 scsi_hba_pkt_comp(pkt);
1269 }
1270 pkt->pkt_reason = CMD_CMPLT;
1271 pkt->pkt_scbp[0] = STATUS_GOOD;
1272 pkt->pkt_state |= STATE_GOT_BUS | STATE_GOT_TARGET
1273 | STATE_SENT_CMD;
1274 return (TRAN_ACCEPT);
1275 }
1276
1277 if (cmd == NULL) {
1278 return (TRAN_BUSY);
1279 }
1280
1281 if ((pkt->pkt_flags & FLAG_NOINTR) == 0) {
1282 if (instance->fw_outstanding > instance->max_fw_cmds) {
1283 con_log(CL_ANN, (CE_CONT, "megasas:Firmware busy"));
1284 return_mfi_pkt(instance, cmd);
1285 return (TRAN_BUSY);
1286 }
1287
1288 /* Syncronize the Cmd frame for the controller */
1289 (void) ddi_dma_sync(cmd->frame_dma_obj.dma_handle, 0, 0,
1290 DDI_DMA_SYNC_FORDEV);
1291
1292 instance->func_ptr->issue_cmd(cmd, instance);
1293
1294 } else {
1295 struct megasas_header *hdr = &cmd->frame->hdr;
1296
1297 cmd->sync_cmd = MEGASAS_TRUE;
1298
1299 instance->func_ptr-> issue_cmd_in_poll_mode(instance, cmd);
1300
1301 pkt->pkt_reason = CMD_CMPLT;
1302 pkt->pkt_statistics = 0;
1303 pkt->pkt_state |= STATE_XFERRED_DATA | STATE_GOT_STATUS;
1304
1305 switch (hdr->cmd_status) {
1306 case MFI_STAT_OK:
1307 pkt->pkt_scbp[0] = STATUS_GOOD;
1308 break;
1309
1310 case MFI_STAT_SCSI_DONE_WITH_ERROR:
1311
1312 pkt->pkt_reason = CMD_CMPLT;
1313 pkt->pkt_statistics = 0;
1314
1315 ((struct scsi_status *)pkt->pkt_scbp)->sts_chk = 1;
1316 break;
1317
1318 case MFI_STAT_DEVICE_NOT_FOUND:
1319 pkt->pkt_reason = CMD_DEV_GONE;
1320 pkt->pkt_statistics = STAT_DISCON;
1321 break;
1322
1323 default:
1324 ((struct scsi_status *)pkt->pkt_scbp)->sts_busy = 1;
1325 }
1326
1327 return_mfi_pkt(instance, cmd);
1328 (void) megasas_common_check(instance, cmd);
1329
1330 scsi_hba_pkt_comp(pkt);
1331
1332 }
1333
1334 return (TRAN_ACCEPT);
1335 }
1336
1337 /*
1338 * tran_abort - Abort any commands that are currently in transport
1339 * @ap:
1340 * @pkt:
1341 *
1342 * The tran_abort() entry point for a SCSI HBA driver is called to abort any
1343 * commands that are currently in transport for a particular target. This entry
1344 * point is called when a target driver calls scsi_abort(). The tran_abort()
1345 * entry point should attempt to abort the command denoted by the pkt
1346 * parameter. If the pkt parameter is NULL, tran_abort() should attempt to
1347 * abort all outstanding commands in the transport layer for the particular
1348 * target or logical unit.
1349 */
1350 /*ARGSUSED*/
1351 static int
1352 megasas_tran_abort(struct scsi_address *ap, struct scsi_pkt *pkt)
1353 {
1354 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1355
1356 /* aborting command not supported by H/W */
1357
1358 return (DDI_FAILURE);
1359 }
1360
1361 /*
1362 * tran_reset - reset either the SCSI bus or target
1363 * @ap:
1364 * @level:
1365 *
1366 * The tran_reset() entry point for a SCSI HBA driver is called to reset either
1367 * the SCSI bus or a particular SCSI target device. This entry point is called
1368 * when a target driver calls scsi_reset(). The tran_reset() entry point must
1369 * reset the SCSI bus if level is RESET_ALL. If level is RESET_TARGET, just the
1370 * particular target or logical unit must be reset.
1371 */
1372 /*ARGSUSED*/
1373 static int
1374 megasas_tran_reset(struct scsi_address *ap, int level)
1375 {
1376 struct megasas_instance *instance = ADDR2MEGA(ap);
1377
1378 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1379
1380 if (wait_for_outstanding(instance)) {
1381 return (DDI_FAILURE);
1382 } else {
1383 return (DDI_SUCCESS);
1384 }
1385 }
1386
1387 /*
1388 * tran_bus_reset - reset the SCSI bus
1389 * @dip:
1390 * @level:
1391 *
1392 * The tran_bus_reset() vector in the scsi_hba_tran structure should be
1393 * initialized during the HBA driver's attach(). The vector should point to
1394 * an HBA entry point that is to be called when a user initiates a bus reset.
1395 * Implementation is hardware specific. If the HBA driver cannot reset the
1396 * SCSI bus without affecting the targets, the driver should fail RESET_BUS
1397 * or not initialize this vector.
1398 */
1399 /*ARGSUSED*/
1400 static int
1401 megasas_tran_bus_reset(dev_info_t *dip, int level)
1402 {
1403 int instance_no = ddi_get_instance(dip);
1404
1405 struct megasas_instance *instance = ddi_get_soft_state(megasas_state,
1406 instance_no);
1407
1408 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1409
1410 if (wait_for_outstanding(instance)) {
1411 return (DDI_FAILURE);
1412 } else {
1413 return (DDI_SUCCESS);
1414 }
1415 }
1416
1417 /*
1418 * tran_getcap - get one of a set of SCSA-defined capabilities
1419 * @ap:
1420 * @cap:
1421 * @whom:
1422 *
1423 * The target driver can request the current setting of the capability for a
1424 * particular target by setting the whom parameter to nonzero. A whom value of
1425 * zero indicates a request for the current setting of the general capability
1426 * for the SCSI bus or for adapter hardware. The tran_getcap() should return -1
1427 * for undefined capabilities or the current value of the requested capability.
1428 */
1429 /*ARGSUSED*/
1430 static int
1431 megasas_tran_getcap(struct scsi_address *ap, char *cap, int whom)
1432 {
1433 int rval = 0;
1434
1435 struct megasas_instance *instance = ADDR2MEGA(ap);
1436
1437 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1438
1439 /* we do allow inquiring about capabilities for other targets */
1440 if (cap == NULL) {
1441 return (-1);
1442 }
1443
1444 switch (scsi_hba_lookup_capstr(cap)) {
1445 case SCSI_CAP_DMA_MAX:
1446 /* Limit to 16MB max transfer */
1447 rval = megasas_max_cap_maxxfer;
1448 break;
1449 case SCSI_CAP_MSG_OUT:
1450 rval = 1;
1451 break;
1452 case SCSI_CAP_DISCONNECT:
1453 rval = 0;
1454 break;
1455 case SCSI_CAP_SYNCHRONOUS:
1456 rval = 0;
1457 break;
1458 case SCSI_CAP_WIDE_XFER:
1459 rval = 1;
1460 break;
1461 case SCSI_CAP_TAGGED_QING:
1462 rval = 1;
1463 break;
1464 case SCSI_CAP_UNTAGGED_QING:
1465 rval = 1;
1466 break;
1467 case SCSI_CAP_PARITY:
1468 rval = 1;
1469 break;
1470 case SCSI_CAP_INITIATOR_ID:
1471 rval = instance->init_id;
1472 break;
1473 case SCSI_CAP_ARQ:
1474 rval = 1;
1475 break;
1476 case SCSI_CAP_LINKED_CMDS:
1477 rval = 0;
1478 break;
1479 case SCSI_CAP_RESET_NOTIFICATION:
1480 rval = 1;
1481 break;
1482 case SCSI_CAP_GEOMETRY:
1483 rval = -1;
1484
1485 break;
1486 default:
1487 con_log(CL_DLEVEL2, (CE_NOTE, "Default cap coming 0x%x",
1488 scsi_hba_lookup_capstr(cap)));
1489 rval = -1;
1490 break;
1491 }
1492
1493 return (rval);
1494 }
1495
1496 /*
1497 * tran_setcap - set one of a set of SCSA-defined capabilities
1498 * @ap:
1499 * @cap:
1500 * @value:
1501 * @whom:
1502 *
1503 * The target driver might request that the new value be set for a particular
1504 * target by setting the whom parameter to nonzero. A whom value of zero
1505 * means that request is to set the new value for the SCSI bus or for adapter
1506 * hardware in general.
1507 * The tran_setcap() should return the following values as appropriate:
1508 * - -1 for undefined capabilities
1509 * - 0 if the HBA driver cannot set the capability to the requested value
1510 * - 1 if the HBA driver is able to set the capability to the requested value
1511 */
1512 /*ARGSUSED*/
1513 static int
1514 megasas_tran_setcap(struct scsi_address *ap, char *cap, int value, int whom)
1515 {
1516 int rval = 1;
1517
1518 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1519
1520 /* We don't allow setting capabilities for other targets */
1521 if (cap == NULL || whom == 0) {
1522 return (-1);
1523 }
1524
1525 switch (scsi_hba_lookup_capstr(cap)) {
1526 case SCSI_CAP_DMA_MAX:
1527 case SCSI_CAP_MSG_OUT:
1528 case SCSI_CAP_PARITY:
1529 case SCSI_CAP_LINKED_CMDS:
1530 case SCSI_CAP_RESET_NOTIFICATION:
1531 case SCSI_CAP_DISCONNECT:
1532 case SCSI_CAP_SYNCHRONOUS:
1533 case SCSI_CAP_UNTAGGED_QING:
1534 case SCSI_CAP_WIDE_XFER:
1535 case SCSI_CAP_INITIATOR_ID:
1536 case SCSI_CAP_ARQ:
1537 /*
1538 * None of these are settable via
1539 * the capability interface.
1540 */
1541 break;
1542 case SCSI_CAP_TAGGED_QING:
1543 rval = 1;
1544 break;
1545 case SCSI_CAP_SECTOR_SIZE:
1546 rval = 1;
1547 break;
1548
1549 case SCSI_CAP_TOTAL_SECTORS:
1550 rval = 1;
1551 break;
1552 default:
1553 rval = -1;
1554 break;
1555 }
1556
1557 return (rval);
1558 }
1559
1560 /*
1561 * tran_destroy_pkt - deallocate scsi_pkt structure
1562 * @ap:
1563 * @pkt:
1564 *
1565 * The tran_destroy_pkt() entry point is the HBA driver function that
1566 * deallocates scsi_pkt structures. The tran_destroy_pkt() entry point is
1567 * called when the target driver calls scsi_destroy_pkt(). The
1568 * tran_destroy_pkt() entry point must free any DMA resources that have been
1569 * allocated for the packet. An implicit DMA synchronization occurs if the
1570 * DMA resources are freed and any cached data remains after the completion
1571 * of the transfer.
1572 */
1573 static void
1574 megasas_tran_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
1575 {
1576 struct scsa_cmd *acmd = PKT2CMD(pkt);
1577
1578 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1579
1580 if (acmd->cmd_flags & CFLAG_DMAVALID) {
1581 acmd->cmd_flags &= ~CFLAG_DMAVALID;
1582
1583 (void) ddi_dma_unbind_handle(acmd->cmd_dmahandle);
1584
1585 ddi_dma_free_handle(&acmd->cmd_dmahandle);
1586
1587 acmd->cmd_dmahandle = NULL;
1588 }
1589
1590 /* free the pkt */
1591 scsi_hba_pkt_free(ap, pkt);
1592 }
1593
1594 /*
1595 * tran_dmafree - deallocates DMA resources
1596 * @ap:
1597 * @pkt:
1598 *
1599 * The tran_dmafree() entry point deallocates DMAQ resources that have been
1600 * allocated for a scsi_pkt structure. The tran_dmafree() entry point is
1601 * called when the target driver calls scsi_dmafree(). The tran_dmafree() must
1602 * free only DMA resources allocated for a scsi_pkt structure, not the
1603 * scsi_pkt itself. When DMA resources are freed, a DMA synchronization is
1604 * implicitly performed.
1605 */
1606 /*ARGSUSED*/
1607 static void
1608 megasas_tran_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
1609 {
1610 register struct scsa_cmd *acmd = PKT2CMD(pkt);
1611
1612 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1613
1614 if (acmd->cmd_flags & CFLAG_DMAVALID) {
1615 acmd->cmd_flags &= ~CFLAG_DMAVALID;
1616
1617 (void) ddi_dma_unbind_handle(acmd->cmd_dmahandle);
1618
1619 ddi_dma_free_handle(&acmd->cmd_dmahandle);
1620
1621 acmd->cmd_dmahandle = NULL;
1622 }
1623 }
1624
1625 /*
1626 * tran_sync_pkt - synchronize the DMA object allocated
1627 * @ap:
1628 * @pkt:
1629 *
1630 * The tran_sync_pkt() entry point synchronizes the DMA object allocated for
1631 * the scsi_pkt structure before or after a DMA transfer. The tran_sync_pkt()
1632 * entry point is called when the target driver calls scsi_sync_pkt(). If the
1633 * data transfer direction is a DMA read from device to memory, tran_sync_pkt()
1634 * must synchronize the CPU's view of the data. If the data transfer direction
1635 * is a DMA write from memory to device, tran_sync_pkt() must synchronize the
1636 * device's view of the data.
1637 */
1638 /*ARGSUSED*/
1639 static void
1640 megasas_tran_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
1641 {
1642 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1643
1644 /*
1645 * following 'ddi_dma_sync()' API call
1646 * already called for each I/O in the ISR
1647 */
1648 #if 0
1649 int i;
1650
1651 register struct scsa_cmd *acmd = PKT2CMD(pkt);
1652
1653 if (acmd->cmd_flags & CFLAG_DMAVALID) {
1654 (void) ddi_dma_sync(acmd->cmd_dmahandle, acmd->cmd_dma_offset,
1655 acmd->cmd_dma_len, (acmd->cmd_flags & CFLAG_DMASEND) ?
1656 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU);
1657 }
1658 #endif
1659 }
1660
1661 /*ARGSUSED*/
1662 static int
1663 megasas_tran_quiesce(dev_info_t *dip)
1664 {
1665 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1666
1667 return (1);
1668 }
1669
1670 /*ARGSUSED*/
1671 static int
1672 megasas_tran_unquiesce(dev_info_t *dip)
1673 {
1674 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1675
1676 return (1);
1677 }
1678
1679 /*
1680 * megasas_isr(caddr_t)
1681 *
1682 * The Interrupt Service Routine
1683 *
1684 * Collect status for all completed commands and do callback
1685 *
1686 */
1687 static uint_t
1688 megasas_isr(struct megasas_instance *instance)
1689 {
1690 int need_softintr;
1691 uint32_t producer;
1692 uint32_t consumer;
1693 uint32_t context;
1694
1695 struct megasas_cmd *cmd;
1696
1697 con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1698
1699 ASSERT(instance);
1700 if (!instance->func_ptr->intr_ack(instance)) {
1701 return (DDI_INTR_UNCLAIMED);
1702 }
1703
1704 (void) ddi_dma_sync(instance->mfi_internal_dma_obj.dma_handle,
1705 0, 0, DDI_DMA_SYNC_FORCPU);
1706
1707 if (megasas_check_dma_handle(instance->mfi_internal_dma_obj.dma_handle)
1708 != DDI_SUCCESS) {
1709 megasas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
1710 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
1711 return (DDI_INTR_UNCLAIMED);
1712 }
1713
1714 producer = *instance->producer;
1715 consumer = *instance->consumer;
1716
1717 con_log(CL_ANN1, (CE_CONT, " producer %x consumer %x ",
1718 producer, consumer));
1719
1720 mutex_enter(&instance->completed_pool_mtx);
1721
1722 while (consumer != producer) {
1723 context = instance->reply_queue[consumer];
1724 cmd = instance->cmd_list[context];
1725 mlist_add_tail(&cmd->list, &instance->completed_pool_list);
1726
1727 consumer++;
1728 if (consumer == (instance->max_fw_cmds + 1)) {
1729 consumer = 0;
1730 }
1731 }
1732
1733 mutex_exit(&instance->completed_pool_mtx);
1734
1735 *instance->consumer = consumer;
1736 (void) ddi_dma_sync(instance->mfi_internal_dma_obj.dma_handle,
1737 0, 0, DDI_DMA_SYNC_FORDEV);
1738
1739 if (instance->softint_running) {
1740 need_softintr = 0;
1741 } else {
1742 need_softintr = 1;
1743 }
1744
1745 if (instance->isr_level == HIGH_LEVEL_INTR) {
1746 if (need_softintr) {
1747 ddi_trigger_softintr(instance->soft_intr_id);
1748 }
1749 } else {
1750 /*
1751 * Not a high-level interrupt, therefore call the soft level
1752 * interrupt explicitly
1753 */
1754 (void) megasas_softintr(instance);
1755 }
1756
1757 return (DDI_INTR_CLAIMED);
1758 }
1759
1760
1761 /*
1762 * ************************************************************************** *
1763 * *
1764 * libraries *
1765 * *
1766 * ************************************************************************** *
1767 */
1768 /*
1769 * get_mfi_pkt : Get a command from the free pool
1770 */
1771 static struct megasas_cmd *
1772 get_mfi_pkt(struct megasas_instance *instance)
1773 {
1774 mlist_t *head = &instance->cmd_pool_list;
1775 struct megasas_cmd *cmd = NULL;
1776
1777 mutex_enter(&instance->cmd_pool_mtx);
1778 ASSERT(mutex_owned(&instance->cmd_pool_mtx));
1779
1780 if (!mlist_empty(head)) {
1781 cmd = mlist_entry(head->next, struct megasas_cmd, list);
1782 mlist_del_init(head->next);
1783 }
1784 if (cmd != NULL)
1785 cmd->pkt = NULL;
1786 mutex_exit(&instance->cmd_pool_mtx);
1787
1788 return (cmd);
1789 }
1790
1791 /*
1792 * return_mfi_pkt : Return a cmd to free command pool
1793 */
1794 static void
1795 return_mfi_pkt(struct megasas_instance *instance, struct megasas_cmd *cmd)
1796 {
1797 mutex_enter(&instance->cmd_pool_mtx);
1798 ASSERT(mutex_owned(&instance->cmd_pool_mtx));
1799
1800 mlist_add(&cmd->list, &instance->cmd_pool_list);
1801
1802 mutex_exit(&instance->cmd_pool_mtx);
1803 }
1804
1805 /*
1806 * destroy_mfi_frame_pool
1807 */
1808 static void
1809 destroy_mfi_frame_pool(struct megasas_instance *instance)
1810 {
1811 int i;
1812 uint32_t max_cmd = instance->max_fw_cmds;
1813
1814 struct megasas_cmd *cmd;
1815
1816 /* return all frames to pool */
1817 for (i = 0; i < max_cmd; i++) {
1818
1819 cmd = instance->cmd_list[i];
1820
1821 if (cmd->frame_dma_obj_status == DMA_OBJ_ALLOCATED)
1822 (void) mega_free_dma_obj(instance, cmd->frame_dma_obj);
1823
1824 cmd->frame_dma_obj_status = DMA_OBJ_FREED;
1825 }
1826
1827 }
1828
1829 /*
1830 * create_mfi_frame_pool
1831 */
1832 static int
1833 create_mfi_frame_pool(struct megasas_instance *instance)
1834 {
1835 int i = 0;
1836 int cookie_cnt;
1837 uint16_t max_cmd;
1838 uint16_t sge_sz;
1839 uint32_t sgl_sz;
1840 uint32_t tot_frame_size;
1841
1842 struct megasas_cmd *cmd;
1843
1844 max_cmd = instance->max_fw_cmds;
1845
1846 sge_sz = sizeof (struct megasas_sge64);
1847
1848 /* calculated the number of 64byte frames required for SGL */
1849 sgl_sz = sge_sz * instance->max_num_sge;
1850 tot_frame_size = sgl_sz + MEGAMFI_FRAME_SIZE + SENSE_LENGTH;
1851
1852 con_log(CL_DLEVEL3, (CE_NOTE, "create_mfi_frame_pool: "
1853 "sgl_sz %x tot_frame_size %x", sgl_sz, tot_frame_size));
1854
1855 while (i < max_cmd) {
1856 cmd = instance->cmd_list[i];
1857
1858 cmd->frame_dma_obj.size = tot_frame_size;
1859 cmd->frame_dma_obj.dma_attr = megasas_generic_dma_attr;
1860 cmd->frame_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
1861 cmd->frame_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
1862 cmd->frame_dma_obj.dma_attr.dma_attr_sgllen = 1;
1863 cmd->frame_dma_obj.dma_attr.dma_attr_align = 64;
1864
1865
1866 cookie_cnt = mega_alloc_dma_obj(instance, &cmd->frame_dma_obj);
1867
1868 if (cookie_cnt == -1 || cookie_cnt > 1) {
1869 con_log(CL_ANN, (CE_WARN,
1870 "create_mfi_frame_pool: could not alloc."));
1871 return (DDI_FAILURE);
1872 }
1873
1874 bzero(cmd->frame_dma_obj.buffer, tot_frame_size);
1875
1876 cmd->frame_dma_obj_status = DMA_OBJ_ALLOCATED;
1877 cmd->frame = (union megasas_frame *)cmd->frame_dma_obj.buffer;
1878 cmd->frame_phys_addr =
1879 cmd->frame_dma_obj.dma_cookie[0].dmac_address;
1880
1881 cmd->sense = (uint8_t *)(((unsigned long)
1882 cmd->frame_dma_obj.buffer) +
1883 tot_frame_size - SENSE_LENGTH);
1884 cmd->sense_phys_addr =
1885 cmd->frame_dma_obj.dma_cookie[0].dmac_address +
1886 tot_frame_size - SENSE_LENGTH;
1887
1888 if (!cmd->frame || !cmd->sense) {
1889 con_log(CL_ANN, (CE_NOTE,
1890 "megasas: pci_pool_alloc failed \n"));
1891
1892 return (-ENOMEM);
1893 }
1894
1895 cmd->frame->io.context = cmd->index;
1896 i++;
1897
1898 con_log(CL_DLEVEL3, (CE_NOTE, "[%x]-%x",
1899 cmd->frame->io.context, cmd->frame_phys_addr));
1900 }
1901
1902 return (DDI_SUCCESS);
1903 }
1904
1905 /*
1906 * free_additional_dma_buffer
1907 */
1908 static void
1909 free_additional_dma_buffer(struct megasas_instance *instance)
1910 {
1911 if (instance->mfi_internal_dma_obj.status == DMA_OBJ_ALLOCATED) {
1912 (void) mega_free_dma_obj(instance,
1913 instance->mfi_internal_dma_obj);
1914 instance->mfi_internal_dma_obj.status = DMA_OBJ_FREED;
1915 }
1916
1917 if (instance->mfi_evt_detail_obj.status == DMA_OBJ_ALLOCATED) {
1918 (void) mega_free_dma_obj(instance,
1919 instance->mfi_evt_detail_obj);
1920 instance->mfi_evt_detail_obj.status = DMA_OBJ_FREED;
1921 }
1922 }
1923
1924 /*
1925 * alloc_additional_dma_buffer
1926 */
1927 static int
1928 alloc_additional_dma_buffer(struct megasas_instance *instance)
1929 {
1930 uint32_t reply_q_sz;
1931 uint32_t internal_buf_size = PAGESIZE*2;
1932
1933 /* max cmds plus 1 + producer & consumer */
1934 reply_q_sz = sizeof (uint32_t) * (instance->max_fw_cmds + 1 + 2);
1935
1936 instance->mfi_internal_dma_obj.size = internal_buf_size;
1937 instance->mfi_internal_dma_obj.dma_attr = megasas_generic_dma_attr;
1938 instance->mfi_internal_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
1939 instance->mfi_internal_dma_obj.dma_attr.dma_attr_count_max =
1940 0xFFFFFFFFU;
1941 instance->mfi_internal_dma_obj.dma_attr.dma_attr_sgllen = 1;
1942
1943 if (mega_alloc_dma_obj(instance, &instance->mfi_internal_dma_obj)
1944 != 1) {
1945 con_log(CL_ANN, (CE_WARN, "megaraid: could not alloc reply Q"));
1946 return (DDI_FAILURE);
1947 }
1948
1949 bzero(instance->mfi_internal_dma_obj.buffer, internal_buf_size);
1950
1951 instance->mfi_internal_dma_obj.status |= DMA_OBJ_ALLOCATED;
1952
1953 instance->producer = (uint32_t *)((unsigned long)
1954 instance->mfi_internal_dma_obj.buffer);
1955 instance->consumer = (uint32_t *)((unsigned long)
1956 instance->mfi_internal_dma_obj.buffer + 4);
1957 instance->reply_queue = (uint32_t *)((unsigned long)
1958 instance->mfi_internal_dma_obj.buffer + 8);
1959 instance->internal_buf = (caddr_t)(((unsigned long)
1960 instance->mfi_internal_dma_obj.buffer) + reply_q_sz + 8);
1961 instance->internal_buf_dmac_add =
1962 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address +
1963 reply_q_sz;
1964 instance->internal_buf_size = internal_buf_size -
1965 (reply_q_sz + 8);
1966
1967 /* allocate evt_detail */
1968 instance->mfi_evt_detail_obj.size = sizeof (struct megasas_evt_detail);
1969 instance->mfi_evt_detail_obj.dma_attr = megasas_generic_dma_attr;
1970 instance->mfi_evt_detail_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
1971 instance->mfi_evt_detail_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
1972 instance->mfi_evt_detail_obj.dma_attr.dma_attr_sgllen = 1;
1973 instance->mfi_evt_detail_obj.dma_attr.dma_attr_align = 1;
1974
1975 if (mega_alloc_dma_obj(instance, &instance->mfi_evt_detail_obj) != 1) {
1976 con_log(CL_ANN, (CE_WARN, "alloc_additional_dma_buffer: "
1977 "could not data transfer buffer alloc."));
1978 return (DDI_FAILURE);
1979 }
1980
1981 bzero(instance->mfi_evt_detail_obj.buffer,
1982 sizeof (struct megasas_evt_detail));
1983
1984 instance->mfi_evt_detail_obj.status |= DMA_OBJ_ALLOCATED;
1985
1986 return (DDI_SUCCESS);
1987 }
1988
1989 /*
1990 * free_space_for_mfi
1991 */
1992 static void
1993 free_space_for_mfi(struct megasas_instance *instance)
1994 {
1995 int i;
1996 uint32_t max_cmd = instance->max_fw_cmds;
1997
1998 /* already freed */
1999 if (instance->cmd_list == NULL) {
2000 return;
2001 }
2002
2003 free_additional_dma_buffer(instance);
2004
2005 /* first free the MFI frame pool */
2006 destroy_mfi_frame_pool(instance);
2007
2008 /* free all the commands in the cmd_list */
2009 for (i = 0; i < instance->max_fw_cmds; i++) {
2010 kmem_free(instance->cmd_list[i],
2011 sizeof (struct megasas_cmd));
2012
2013 instance->cmd_list[i] = NULL;
2014 }
2015
2016 /* free the cmd_list buffer itself */
2017 kmem_free(instance->cmd_list,
2018 sizeof (struct megasas_cmd *) * max_cmd);
2019
2020 instance->cmd_list = NULL;
2021
2022 INIT_LIST_HEAD(&instance->cmd_pool_list);
2023 }
2024
2025 /*
2026 * alloc_space_for_mfi
2027 */
2028 static int
2029 alloc_space_for_mfi(struct megasas_instance *instance)
2030 {
2031 int i;
2032 uint32_t max_cmd;
2033 size_t sz;
2034
2035 struct megasas_cmd *cmd;
2036
2037 max_cmd = instance->max_fw_cmds;
2038 sz = sizeof (struct megasas_cmd *) * max_cmd;
2039
2040 /*
2041 * instance->cmd_list is an array of struct megasas_cmd pointers.
2042 * Allocate the dynamic array first and then allocate individual
2043 * commands.
2044 */
2045 instance->cmd_list = kmem_zalloc(sz, KM_SLEEP);
2046 ASSERT(instance->cmd_list);
2047
2048 for (i = 0; i < max_cmd; i++) {
2049 instance->cmd_list[i] = kmem_zalloc(sizeof (struct megasas_cmd),
2050 KM_SLEEP);
2051 ASSERT(instance->cmd_list[i]);
2052 }
2053
2054 INIT_LIST_HEAD(&instance->cmd_pool_list);
2055
2056 /* add all the commands to command pool (instance->cmd_pool) */
2057 for (i = 0; i < max_cmd; i++) {
2058 cmd = instance->cmd_list[i];
2059 cmd->index = i;
2060
2061 mlist_add_tail(&cmd->list, &instance->cmd_pool_list);
2062 }
2063
2064 /* create a frame pool and assign one frame to each cmd */
2065 if (create_mfi_frame_pool(instance)) {
2066 con_log(CL_ANN, (CE_NOTE, "error creating frame DMA pool\n"));
2067 return (DDI_FAILURE);
2068 }
2069
2070 /* create a frame pool and assign one frame to each cmd */
2071 if (alloc_additional_dma_buffer(instance)) {
2072 con_log(CL_ANN, (CE_NOTE, "error creating frame DMA pool\n"));
2073 return (DDI_FAILURE);
2074 }
2075
2076 return (DDI_SUCCESS);
2077 }
2078
2079 /*
2080 * get_ctrl_info
2081 */
2082 static int
2083 get_ctrl_info(struct megasas_instance *instance,
2084 struct megasas_ctrl_info *ctrl_info)
2085 {
2086 int ret = 0;
2087
2088 struct megasas_cmd *cmd;
2089 struct megasas_dcmd_frame *dcmd;
2090 struct megasas_ctrl_info *ci;
2091
2092 cmd = get_mfi_pkt(instance);
2093
2094 if (!cmd) {
2095 con_log(CL_ANN, (CE_WARN,
2096 "Failed to get a cmd for ctrl info\n"));
2097 return (DDI_FAILURE);
2098 }
2099
2100 dcmd = &cmd->frame->dcmd;
2101
2102 ci = (struct megasas_ctrl_info *)instance->internal_buf;
2103
2104 if (!ci) {
2105 con_log(CL_ANN, (CE_WARN,
2106 "Failed to alloc mem for ctrl info\n"));
2107 return_mfi_pkt(instance, cmd);
2108 return (DDI_FAILURE);
2109 }
2110
2111 (void) memset(ci, 0, sizeof (struct megasas_ctrl_info));
2112
2113 /* for( i = 0; i < DCMD_MBOX_SZ; i++ ) dcmd->mbox.b[i] = 0; */
2114 (void) memset(dcmd->mbox.b, 0, DCMD_MBOX_SZ);
2115
2116 dcmd->cmd = MFI_CMD_OP_DCMD;
2117 dcmd->cmd_status = MFI_CMD_STATUS_POLL_MODE;
2118 dcmd->sge_count = 1;
2119 dcmd->flags = MFI_FRAME_DIR_READ;
2120 dcmd->timeout = 0;
2121 dcmd->data_xfer_len = sizeof (struct megasas_ctrl_info);
2122 dcmd->opcode = MR_DCMD_CTRL_GET_INFO;
2123 dcmd->sgl.sge32[0].phys_addr = instance->internal_buf_dmac_add;
2124 dcmd->sgl.sge32[0].length = sizeof (struct megasas_ctrl_info);
2125
2126 cmd->frame_count = 1;
2127
2128 if (!instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
2129 ret = 0;
2130 (void) memcpy(ctrl_info, ci, sizeof (struct megasas_ctrl_info));
2131 } else {
2132 con_log(CL_ANN, (CE_WARN, "get_ctrl_info: Ctrl info failed\n"));
2133 ret = -1;
2134 }
2135
2136 return_mfi_pkt(instance, cmd);
2137 if (megasas_common_check(instance, cmd) != DDI_SUCCESS) {
2138 ret = -1;
2139 }
2140
2141 return (ret);
2142 }
2143
2144 /*
2145 * abort_aen_cmd
2146 */
2147 static int
2148 abort_aen_cmd(struct megasas_instance *instance,
2149 struct megasas_cmd *cmd_to_abort)
2150 {
2151 int ret = 0;
2152
2153 struct megasas_cmd *cmd;
2154 struct megasas_abort_frame *abort_fr;
2155
2156 cmd = get_mfi_pkt(instance);
2157
2158 if (!cmd) {
2159 con_log(CL_ANN, (CE_WARN,
2160 "Failed to get a cmd for ctrl info\n"));
2161 return (DDI_FAILURE);
2162 }
2163
2164 abort_fr = &cmd->frame->abort;
2165
2166 /* prepare and issue the abort frame */
2167 abort_fr->cmd = MFI_CMD_OP_ABORT;
2168 abort_fr->cmd_status = MFI_CMD_STATUS_SYNC_MODE;
2169 abort_fr->flags = 0;
2170 abort_fr->abort_context = cmd_to_abort->index;
2171 abort_fr->abort_mfi_phys_addr_lo = cmd_to_abort->frame_phys_addr;
2172 abort_fr->abort_mfi_phys_addr_hi = 0;
2173
2174 instance->aen_cmd->abort_aen = 1;
2175
2176 cmd->sync_cmd = MEGASAS_TRUE;
2177 cmd->frame_count = 1;
2178
2179 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
2180 con_log(CL_ANN, (CE_WARN,
2181 "abort_aen_cmd: issue_cmd_in_sync_mode failed\n"));
2182 ret = -1;
2183 } else {
2184 ret = 0;
2185 }
2186
2187 instance->aen_cmd->abort_aen = 1;
2188 instance->aen_cmd = 0;
2189
2190 return_mfi_pkt(instance, cmd);
2191 (void) megasas_common_check(instance, cmd);
2192
2193 return (ret);
2194 }
2195
2196 /*
2197 * init_mfi
2198 */
2199 static int
2200 init_mfi(struct megasas_instance *instance)
2201 {
2202 off_t reglength;
2203 struct megasas_cmd *cmd;
2204 struct megasas_ctrl_info ctrl_info;
2205 struct megasas_init_frame *init_frame;
2206 struct megasas_init_queue_info *initq_info;
2207
2208 if ((ddi_dev_regsize(instance->dip, REGISTER_SET_IO, ®length)
2209 != DDI_SUCCESS) || reglength < MINIMUM_MFI_MEM_SZ) {
2210 return (DDI_FAILURE);
2211 }
2212
2213 if (reglength > DEFAULT_MFI_MEM_SZ) {
2214 reglength = DEFAULT_MFI_MEM_SZ;
2215 con_log(CL_DLEVEL1, (CE_NOTE,
2216 "mega: register length to map is 0x%lx bytes", reglength));
2217 }
2218
2219 if (ddi_regs_map_setup(instance->dip, REGISTER_SET_IO,
2220 &instance->regmap, 0, reglength, &endian_attr,
2221 &instance->regmap_handle) != DDI_SUCCESS) {
2222 con_log(CL_ANN, (CE_NOTE,
2223 "megaraid: couldn't map control registers"));
2224
2225 goto fail_mfi_reg_setup;
2226 }
2227
2228 /* we expect the FW state to be READY */
2229 if (mfi_state_transition_to_ready(instance)) {
2230 con_log(CL_ANN, (CE_WARN, "megaraid: F/W is not ready"));
2231 goto fail_ready_state;
2232 }
2233
2234 /* get various operational parameters from status register */
2235 instance->max_num_sge =
2236 (instance->func_ptr->read_fw_status_reg(instance) &
2237 0xFF0000) >> 0x10;
2238 /*
2239 * Reduce the max supported cmds by 1. This is to ensure that the
2240 * reply_q_sz (1 more than the max cmd that driver may send)
2241 * does not exceed max cmds that the FW can support
2242 */
2243 instance->max_fw_cmds =
2244 instance->func_ptr->read_fw_status_reg(instance) & 0xFFFF;
2245 instance->max_fw_cmds = instance->max_fw_cmds - 1;
2246
2247 instance->max_num_sge =
2248 (instance->max_num_sge > MEGASAS_MAX_SGE_CNT) ?
2249 MEGASAS_MAX_SGE_CNT : instance->max_num_sge;
2250
2251 /* create a pool of commands */
2252 if (alloc_space_for_mfi(instance))
2253 goto fail_alloc_fw_space;
2254
2255 /* disable interrupt for initial preparation */
2256 instance->func_ptr->disable_intr(instance);
2257
2258 /*
2259 * Prepare a init frame. Note the init frame points to queue info
2260 * structure. Each frame has SGL allocated after first 64 bytes. For
2261 * this frame - since we don't need any SGL - we use SGL's space as
2262 * queue info structure
2263 */
2264 cmd = get_mfi_pkt(instance);
2265
2266 init_frame = (struct megasas_init_frame *)cmd->frame;
2267 initq_info = (struct megasas_init_queue_info *)
2268 ((unsigned long)init_frame + 64);
2269
2270 (void) memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
2271 (void) memset(initq_info, 0, sizeof (struct megasas_init_queue_info));
2272
2273 initq_info->init_flags = 0;
2274
2275 initq_info->reply_queue_entries = instance->max_fw_cmds + 1;
2276
2277 initq_info->producer_index_phys_addr_hi = 0;
2278 initq_info->producer_index_phys_addr_lo =
2279 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address;
2280
2281 initq_info->consumer_index_phys_addr_hi = 0;
2282 initq_info->consumer_index_phys_addr_lo =
2283 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address + 4;
2284
2285 initq_info->reply_queue_start_phys_addr_hi = 0;
2286 initq_info->reply_queue_start_phys_addr_lo =
2287 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address + 8;
2288
2289 init_frame->cmd = MFI_CMD_OP_INIT;
2290 init_frame->cmd_status = MFI_CMD_STATUS_POLL_MODE;
2291 init_frame->flags = 0;
2292 init_frame->queue_info_new_phys_addr_lo =
2293 cmd->frame_phys_addr + 64;
2294 init_frame->queue_info_new_phys_addr_hi = 0;
2295
2296 init_frame->data_xfer_len = sizeof (struct megasas_init_queue_info);
2297
2298 cmd->frame_count = 1;
2299
2300 /* issue the init frame in polled mode */
2301 if (instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
2302 con_log(CL_ANN, (CE_WARN, "failed to init firmware"));
2303 goto fail_fw_init;
2304 }
2305
2306 return_mfi_pkt(instance, cmd);
2307 if (megasas_common_check(instance, cmd) != DDI_SUCCESS) {
2308 goto fail_fw_init;
2309 }
2310
2311 /* gather misc FW related information */
2312 if (!get_ctrl_info(instance, &ctrl_info)) {
2313 instance->max_sectors_per_req = ctrl_info.max_request_size;
2314 con_log(CL_ANN1, (CE_NOTE, "product name %s ld present %d",
2315 ctrl_info.product_name, ctrl_info.ld_present_count));
2316 } else {
2317 instance->max_sectors_per_req = instance->max_num_sge *
2318 PAGESIZE / 512;
2319 }
2320
2321 if (megasas_check_acc_handle(instance->regmap_handle) != DDI_SUCCESS) {
2322 goto fail_fw_init;
2323 }
2324
2325 return (0);
2326
2327 fail_fw_init:
2328 fail_alloc_fw_space:
2329
2330 free_space_for_mfi(instance);
2331
2332 fail_ready_state:
2333 ddi_regs_map_free(&instance->regmap_handle);
2334
2335 fail_mfi_reg_setup:
2336 return (DDI_FAILURE);
2337 }
2338
2339 /*
2340 * mfi_state_transition_to_ready : Move the FW to READY state
2341 *
2342 * @reg_set : MFI register set
2343 */
2344 static int
2345 mfi_state_transition_to_ready(struct megasas_instance *instance)
2346 {
2347 int i;
2348 uint8_t max_wait;
2349 uint32_t fw_ctrl;
2350 uint32_t fw_state;
2351 uint32_t cur_state;
2352
2353 fw_state =
2354 instance->func_ptr->read_fw_status_reg(instance) & MFI_STATE_MASK;
2355 con_log(CL_ANN1, (CE_NOTE,
2356 "mfi_state_transition_to_ready:FW state = 0x%x", fw_state));
2357
2358 while (fw_state != MFI_STATE_READY) {
2359 con_log(CL_ANN, (CE_NOTE,
2360 "mfi_state_transition_to_ready:FW state%x", fw_state));
2361
2362 switch (fw_state) {
2363 case MFI_STATE_FAULT:
2364 con_log(CL_ANN, (CE_NOTE,
2365 "megasas: FW in FAULT state!!"));
2366
2367 return (-ENODEV);
2368 case MFI_STATE_WAIT_HANDSHAKE:
2369 /* set the CLR bit in IMR0 */
2370 con_log(CL_ANN, (CE_NOTE,
2371 "megasas: FW waiting for HANDSHAKE"));
2372 /*
2373 * PCI_Hot Plug: MFI F/W requires
2374 * (MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG)
2375 * to be set
2376 */
2377 /* WR_IB_MSG_0(MFI_INIT_CLEAR_HANDSHAKE, instance); */
2378 WR_IB_DOORBELL(MFI_INIT_CLEAR_HANDSHAKE |
2379 MFI_INIT_HOTPLUG, instance);
2380
2381 max_wait = 2;
2382 cur_state = MFI_STATE_WAIT_HANDSHAKE;
2383 break;
2384 case MFI_STATE_BOOT_MESSAGE_PENDING:
2385 /* set the CLR bit in IMR0 */
2386 con_log(CL_ANN, (CE_NOTE,
2387 "megasas: FW state boot message pending"));
2388 /*
2389 * PCI_Hot Plug: MFI F/W requires
2390 * (MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG)
2391 * to be set
2392 */
2393 WR_IB_DOORBELL(MFI_INIT_HOTPLUG, instance);
2394
2395 max_wait = 10;
2396 cur_state = MFI_STATE_BOOT_MESSAGE_PENDING;
2397 break;
2398 case MFI_STATE_OPERATIONAL:
2399 /* bring it to READY state; assuming max wait 2 secs */
2400 instance->func_ptr->disable_intr(instance);
2401 con_log(CL_ANN1, (CE_NOTE,
2402 "megasas: FW in OPERATIONAL state"));
2403 /*
2404 * PCI_Hot Plug: MFI F/W requires
2405 * (MFI_INIT_READY | MFI_INIT_MFIMODE | MFI_INIT_ABORT)
2406 * to be set
2407 */
2408 /* WR_IB_DOORBELL(MFI_INIT_READY, instance); */
2409 WR_IB_DOORBELL(MFI_RESET_FLAGS, instance);
2410
2411 max_wait = 10;
2412 cur_state = MFI_STATE_OPERATIONAL;
2413 break;
2414 case MFI_STATE_UNDEFINED:
2415 /* this state should not last for more than 2 seconds */
2416 con_log(CL_ANN, (CE_NOTE, "FW state undefined\n"));
2417
2418 max_wait = 2;
2419 cur_state = MFI_STATE_UNDEFINED;
2420 break;
2421 case MFI_STATE_BB_INIT:
2422 max_wait = 2;
2423 cur_state = MFI_STATE_BB_INIT;
2424 break;
2425 case MFI_STATE_FW_INIT:
2426 max_wait = 2;
2427 cur_state = MFI_STATE_FW_INIT;
2428 break;
2429 case MFI_STATE_DEVICE_SCAN:
2430 max_wait = 10;
2431 cur_state = MFI_STATE_DEVICE_SCAN;
2432 break;
2433 default:
2434 con_log(CL_ANN, (CE_NOTE,
2435 "megasas: Unknown state 0x%x\n", fw_state));
2436 return (-ENODEV);
2437 }
2438
2439 /* the cur_state should not last for more than max_wait secs */
2440 for (i = 0; i < (max_wait * MILLISEC); i++) {
2441 /* fw_state = RD_OB_MSG_0(instance) & MFI_STATE_MASK; */
2442 fw_state =
2443 instance->func_ptr->read_fw_status_reg(instance) &
2444 MFI_STATE_MASK;
2445
2446 if (fw_state == cur_state) {
2447 delay(1 * drv_usectohz(MILLISEC));
2448 } else {
2449 break;
2450 }
2451 }
2452
2453 /* return error if fw_state hasn't changed after max_wait */
2454 if (fw_state == cur_state) {
2455 con_log(CL_ANN, (CE_NOTE,
2456 "FW state hasn't changed in %d secs\n", max_wait));
2457 return (-ENODEV);
2458 }
2459 };
2460
2461 fw_ctrl = RD_IB_DOORBELL(instance);
2462
2463 con_log(CL_ANN1, (CE_NOTE,
2464 "mfi_state_transition_to_ready:FW ctrl = 0x%x", fw_ctrl));
2465
2466 /*
2467 * Write 0xF to the doorbell register to do the following.
2468 * - Abort all outstanding commands (bit 0).
2469 * - Transition from OPERATIONAL to READY state (bit 1).
2470 * - Discard (possible) low MFA posted in 64-bit mode (bit-2).
2471 * - Set to release FW to continue running (i.e. BIOS handshake
2472 * (bit 3).
2473 */
2474 WR_IB_DOORBELL(0xF, instance);
2475
2476 if (megasas_check_acc_handle(instance->regmap_handle) != DDI_SUCCESS) {
2477 return (-ENODEV);
2478 }
2479 return (0);
2480 }
2481
2482 /*
2483 * get_seq_num
2484 */
2485 static int
2486 get_seq_num(struct megasas_instance *instance,
2487 struct megasas_evt_log_info *eli)
2488 {
2489 int ret = 0;
2490
2491 dma_obj_t dcmd_dma_obj;
2492 struct megasas_cmd *cmd;
2493 struct megasas_dcmd_frame *dcmd;
2494
2495 cmd = get_mfi_pkt(instance);
2496
2497 if (!cmd) {
2498 cmn_err(CE_WARN, "megasas: failed to get a cmd\n");
2499 return (-ENOMEM);
2500 }
2501
2502 dcmd = &cmd->frame->dcmd;
2503
2504 /* allocate the data transfer buffer */
2505 dcmd_dma_obj.size = sizeof (struct megasas_evt_log_info);
2506 dcmd_dma_obj.dma_attr = megasas_generic_dma_attr;
2507 dcmd_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
2508 dcmd_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
2509 dcmd_dma_obj.dma_attr.dma_attr_sgllen = 1;
2510 dcmd_dma_obj.dma_attr.dma_attr_align = 1;
2511
2512 if (mega_alloc_dma_obj(instance, &dcmd_dma_obj) != 1) {
2513 con_log(CL_ANN, (CE_WARN,
2514 "get_seq_num: could not data transfer buffer alloc."));
2515 return (DDI_FAILURE);
2516 }
2517
2518 (void) memset(dcmd_dma_obj.buffer, 0,
2519 sizeof (struct megasas_evt_log_info));
2520
2521 (void) memset(dcmd->mbox.b, 0, DCMD_MBOX_SZ);
2522
2523 dcmd->cmd = MFI_CMD_OP_DCMD;
2524 dcmd->cmd_status = 0;
2525 dcmd->sge_count = 1;
2526 dcmd->flags = MFI_FRAME_DIR_READ;
2527 dcmd->timeout = 0;
2528 dcmd->data_xfer_len = sizeof (struct megasas_evt_log_info);
2529 dcmd->opcode = MR_DCMD_CTRL_EVENT_GET_INFO;
2530 dcmd->sgl.sge32[0].length = sizeof (struct megasas_evt_log_info);
2531 dcmd->sgl.sge32[0].phys_addr = dcmd_dma_obj.dma_cookie[0].dmac_address;
2532
2533 cmd->sync_cmd = MEGASAS_TRUE;
2534 cmd->frame_count = 1;
2535
2536 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
2537 cmn_err(CE_WARN, "get_seq_num: "
2538 "failed to issue MR_DCMD_CTRL_EVENT_GET_INFO\n");
2539 ret = -1;
2540 } else {
2541 /* copy the data back into callers buffer */
2542 bcopy(dcmd_dma_obj.buffer, eli,
2543 sizeof (struct megasas_evt_log_info));
2544 ret = 0;
2545 }
2546
2547 if (mega_free_dma_obj(instance, dcmd_dma_obj) != DDI_SUCCESS)
2548 ret = -1;
2549
2550 return_mfi_pkt(instance, cmd);
2551 if (megasas_common_check(instance, cmd) != DDI_SUCCESS) {
2552 ret = -1;
2553 }
2554 return (ret);
2555 }
2556
2557 /*
2558 * start_mfi_aen
2559 */
2560 static int
2561 start_mfi_aen(struct megasas_instance *instance)
2562 {
2563 int ret = 0;
2564
2565 struct megasas_evt_log_info eli;
2566 union megasas_evt_class_locale class_locale;
2567
2568 /* get the latest sequence number from FW */
2569 (void) memset(&eli, 0, sizeof (struct megasas_evt_log_info));
2570
2571 if (get_seq_num(instance, &eli)) {
2572 cmn_err(CE_WARN, "start_mfi_aen: failed to get seq num\n");
2573 return (-1);
2574 }
2575
2576 /* register AEN with FW for latest sequence number plus 1 */
2577 class_locale.members.reserved = 0;
2578 class_locale.members.locale = MR_EVT_LOCALE_ALL;
2579 class_locale.members.class = MR_EVT_CLASS_CRITICAL;
2580
2581 ret = register_mfi_aen(instance, eli.newest_seq_num + 1,
2582 class_locale.word);
2583
2584 if (ret) {
2585 cmn_err(CE_WARN, "start_mfi_aen: aen registration failed\n");
2586 return (-1);
2587 }
2588
2589 return (ret);
2590 }
2591
2592 /*
2593 * flush_cache
2594 */
2595 static void
2596 flush_cache(struct megasas_instance *instance)
2597 {
2598 struct megasas_cmd *cmd;
2599 struct megasas_dcmd_frame *dcmd;
2600
2601 if (!(cmd = get_mfi_pkt(instance)))
2602 return;
2603
2604 dcmd = &cmd->frame->dcmd;
2605
2606 (void) memset(dcmd->mbox.b, 0, DCMD_MBOX_SZ);
2607
2608 dcmd->cmd = MFI_CMD_OP_DCMD;
2609 dcmd->cmd_status = 0x0;
2610 dcmd->sge_count = 0;
2611 dcmd->flags = MFI_FRAME_DIR_NONE;
2612 dcmd->timeout = 0;
2613 dcmd->data_xfer_len = 0;
2614 dcmd->opcode = MR_DCMD_CTRL_CACHE_FLUSH;
2615 dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
2616
2617 cmd->frame_count = 1;
2618
2619 if (instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
2620 cmn_err(CE_WARN,
2621 "flush_cache: failed to issue MFI_DCMD_CTRL_CACHE_FLUSH\n");
2622 }
2623 con_log(CL_DLEVEL1, (CE_NOTE, "done"));
2624 return_mfi_pkt(instance, cmd);
2625 (void) megasas_common_check(instance, cmd);
2626 }
2627
2628 /*
2629 * service_mfi_aen- Completes an AEN command
2630 * @instance: Adapter soft state
2631 * @cmd: Command to be completed
2632 *
2633 */
2634 static void
2635 service_mfi_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
2636 {
2637 uint32_t seq_num;
2638 struct megasas_evt_detail *evt_detail =
2639 (struct megasas_evt_detail *)instance->mfi_evt_detail_obj.buffer;
2640
2641 cmd->cmd_status = cmd->frame->io.cmd_status;
2642
2643 if (cmd->cmd_status == ENODATA) {
2644 cmd->cmd_status = 0;
2645 }
2646
2647 /*
2648 * log the MFI AEN event to the sysevent queue so that
2649 * application will get noticed
2650 */
2651 if (ddi_log_sysevent(instance->dip, DDI_VENDOR_LSI, "LSIMEGA", "SAS",
2652 NULL, NULL, DDI_NOSLEEP) != DDI_SUCCESS) {
2653 int instance_no = ddi_get_instance(instance->dip);
2654 con_log(CL_ANN, (CE_WARN,
2655 "mega%d: Failed to log AEN event", instance_no));
2656 }
2657
2658 /* get copy of seq_num and class/locale for re-registration */
2659 seq_num = evt_detail->seq_num;
2660 seq_num++;
2661 (void) memset(instance->mfi_evt_detail_obj.buffer, 0,
2662 sizeof (struct megasas_evt_detail));
2663
2664 cmd->frame->dcmd.cmd_status = 0x0;
2665 cmd->frame->dcmd.mbox.w[0] = seq_num;
2666
2667 instance->aen_seq_num = seq_num;
2668
2669 cmd->frame_count = 1;
2670
2671 /* Issue the aen registration frame */
2672 instance->func_ptr->issue_cmd(cmd, instance);
2673 }
2674
2675 /*
2676 * complete_cmd_in_sync_mode - Completes an internal command
2677 * @instance: Adapter soft state
2678 * @cmd: Command to be completed
2679 *
2680 * The issue_cmd_in_sync_mode() function waits for a command to complete
2681 * after it issues a command. This function wakes up that waiting routine by
2682 * calling wake_up() on the wait queue.
2683 */
2684 static void
2685 complete_cmd_in_sync_mode(struct megasas_instance *instance,
2686 struct megasas_cmd *cmd)
2687 {
2688 cmd->cmd_status = cmd->frame->io.cmd_status;
2689
2690 cmd->sync_cmd = MEGASAS_FALSE;
2691
2692 if (cmd->cmd_status == ENODATA) {
2693 cmd->cmd_status = 0;
2694 }
2695
2696 cv_broadcast(&instance->int_cmd_cv);
2697 }
2698
2699 /*
2700 * megasas_softintr - The Software ISR
2701 * @param arg : HBA soft state
2702 *
2703 * called from high-level interrupt if hi-level interrupt are not there,
2704 * otherwise triggered as a soft interrupt
2705 */
2706 static uint_t
2707 megasas_softintr(struct megasas_instance *instance)
2708 {
2709 struct scsi_pkt *pkt;
2710 struct scsa_cmd *acmd;
2711 struct megasas_cmd *cmd;
2712 struct mlist_head *pos, *next;
2713 mlist_t process_list;
2714 struct megasas_header *hdr;
2715 struct scsi_arq_status *arqstat;
2716
2717 con_log(CL_ANN1, (CE_CONT, "megasas_softintr called"));
2718
2719 ASSERT(instance);
2720 mutex_enter(&instance->completed_pool_mtx);
2721
2722 if (mlist_empty(&instance->completed_pool_list)) {
2723 mutex_exit(&instance->completed_pool_mtx);
2724 return (DDI_INTR_UNCLAIMED);
2725 }
2726
2727 instance->softint_running = 1;
2728
2729 INIT_LIST_HEAD(&process_list);
2730 mlist_splice(&instance->completed_pool_list, &process_list);
2731 INIT_LIST_HEAD(&instance->completed_pool_list);
2732
2733 mutex_exit(&instance->completed_pool_mtx);
2734
2735 /* perform all callbacks first, before releasing the SCBs */
2736 mlist_for_each_safe(pos, next, &process_list) {
2737 cmd = mlist_entry(pos, struct megasas_cmd, list);
2738
2739 /* syncronize the Cmd frame for the controller */
2740 (void) ddi_dma_sync(cmd->frame_dma_obj.dma_handle,
2741 0, 0, DDI_DMA_SYNC_FORCPU);
2742
2743 if (megasas_check_dma_handle(cmd->frame_dma_obj.dma_handle) !=
2744 DDI_SUCCESS) {
2745 megasas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
2746 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
2747 return (DDI_INTR_UNCLAIMED);
2748 }
2749
2750 hdr = &cmd->frame->hdr;
2751
2752 /* remove the internal command from the process list */
2753 mlist_del_init(&cmd->list);
2754
2755 switch (hdr->cmd) {
2756 case MFI_CMD_OP_PD_SCSI:
2757 case MFI_CMD_OP_LD_SCSI:
2758 case MFI_CMD_OP_LD_READ:
2759 case MFI_CMD_OP_LD_WRITE:
2760 /*
2761 * MFI_CMD_OP_PD_SCSI and MFI_CMD_OP_LD_SCSI
2762 * could have been issued either through an
2763 * IO path or an IOCTL path. If it was via IOCTL,
2764 * we will send it to internal completion.
2765 */
2766 if (cmd->sync_cmd == MEGASAS_TRUE) {
2767 complete_cmd_in_sync_mode(instance, cmd);
2768 break;
2769 }
2770
2771 /* regular commands */
2772 acmd = cmd->cmd;
2773 pkt = CMD2PKT(acmd);
2774
2775 if (acmd->cmd_flags & CFLAG_DMAVALID) {
2776 if (acmd->cmd_flags & CFLAG_CONSISTENT) {
2777 (void) ddi_dma_sync(acmd->cmd_dmahandle,
2778 acmd->cmd_dma_offset,
2779 acmd->cmd_dma_len,
2780 DDI_DMA_SYNC_FORCPU);
2781 }
2782 }
2783
2784 pkt->pkt_reason = CMD_CMPLT;
2785 pkt->pkt_statistics = 0;
2786 pkt->pkt_state = STATE_GOT_BUS
2787 | STATE_GOT_TARGET | STATE_SENT_CMD
2788 | STATE_XFERRED_DATA | STATE_GOT_STATUS;
2789
2790 con_log(CL_ANN1, (CE_CONT,
2791 "CDB[0] = %x completed for %s: size %lx context %x",
2792 pkt->pkt_cdbp[0], ((acmd->islogical) ? "LD" : "PD"),
2793 acmd->cmd_dmacount, hdr->context));
2794
2795 if (pkt->pkt_cdbp[0] == SCMD_INQUIRY) {
2796 struct scsi_inquiry *inq;
2797
2798 if (acmd->cmd_dmacount != 0) {
2799 bp_mapin(acmd->cmd_buf);
2800 inq = (struct scsi_inquiry *)
2801 acmd->cmd_buf->b_un.b_addr;
2802
2803 /* don't expose physical drives to OS */
2804 if (acmd->islogical &&
2805 (hdr->cmd_status == MFI_STAT_OK)) {
2806 display_scsi_inquiry(
2807 (caddr_t)inq);
2808 } else if ((hdr->cmd_status ==
2809 MFI_STAT_OK) && inq->inq_dtype ==
2810 DTYPE_DIRECT) {
2811
2812 display_scsi_inquiry(
2813 (caddr_t)inq);
2814
2815 /* for physical disk */
2816 hdr->cmd_status =
2817 MFI_STAT_DEVICE_NOT_FOUND;
2818 }
2819 }
2820 }
2821
2822 switch (hdr->cmd_status) {
2823 case MFI_STAT_OK:
2824 pkt->pkt_scbp[0] = STATUS_GOOD;
2825 break;
2826 case MFI_STAT_LD_CC_IN_PROGRESS:
2827 case MFI_STAT_LD_RECON_IN_PROGRESS:
2828 /* SJ - these are not correct way */
2829 pkt->pkt_scbp[0] = STATUS_GOOD;
2830 break;
2831 case MFI_STAT_LD_INIT_IN_PROGRESS:
2832 con_log(CL_ANN,
2833 (CE_WARN, "Initialization in Progress"));
2834 pkt->pkt_reason = CMD_TRAN_ERR;
2835
2836 break;
2837 case MFI_STAT_SCSI_DONE_WITH_ERROR:
2838 con_log(CL_ANN1, (CE_CONT, "scsi_done error"));
2839
2840 pkt->pkt_reason = CMD_CMPLT;
2841 ((struct scsi_status *)
2842 pkt->pkt_scbp)->sts_chk = 1;
2843
2844 if (pkt->pkt_cdbp[0] == SCMD_TEST_UNIT_READY) {
2845
2846 con_log(CL_ANN,
2847 (CE_WARN, "TEST_UNIT_READY fail"));
2848
2849 } else {
2850 pkt->pkt_state |= STATE_ARQ_DONE;
2851 arqstat = (void *)(pkt->pkt_scbp);
2852 arqstat->sts_rqpkt_reason = CMD_CMPLT;
2853 arqstat->sts_rqpkt_resid = 0;
2854 arqstat->sts_rqpkt_state |=
2855 STATE_GOT_BUS | STATE_GOT_TARGET
2856 | STATE_SENT_CMD
2857 | STATE_XFERRED_DATA;
2858 *(uint8_t *)&arqstat->sts_rqpkt_status =
2859 STATUS_GOOD;
2860
2861 bcopy(cmd->sense,
2862 &(arqstat->sts_sensedata),
2863 acmd->cmd_scblen -
2864 offsetof(struct scsi_arq_status,
2865 sts_sensedata));
2866 }
2867 break;
2868 case MFI_STAT_LD_OFFLINE:
2869 case MFI_STAT_DEVICE_NOT_FOUND:
2870 con_log(CL_ANN1, (CE_CONT,
2871 "device not found error"));
2872 pkt->pkt_reason = CMD_DEV_GONE;
2873 pkt->pkt_statistics = STAT_DISCON;
2874 break;
2875 case MFI_STAT_LD_LBA_OUT_OF_RANGE:
2876 pkt->pkt_state |= STATE_ARQ_DONE;
2877 pkt->pkt_reason = CMD_CMPLT;
2878 ((struct scsi_status *)
2879 pkt->pkt_scbp)->sts_chk = 1;
2880
2881 arqstat = (void *)(pkt->pkt_scbp);
2882 arqstat->sts_rqpkt_reason = CMD_CMPLT;
2883 arqstat->sts_rqpkt_resid = 0;
2884 arqstat->sts_rqpkt_state |= STATE_GOT_BUS
2885 | STATE_GOT_TARGET | STATE_SENT_CMD
2886 | STATE_XFERRED_DATA;
2887 *(uint8_t *)&arqstat->sts_rqpkt_status =
2888 STATUS_GOOD;
2889
2890 arqstat->sts_sensedata.es_valid = 1;
2891 arqstat->sts_sensedata.es_key =
2892 KEY_ILLEGAL_REQUEST;
2893 arqstat->sts_sensedata.es_class =
2894 CLASS_EXTENDED_SENSE;
2895
2896 /*
2897 * LOGICAL BLOCK ADDRESS OUT OF RANGE:
2898 * ASC: 0x21h; ASCQ: 0x00h;
2899 */
2900 arqstat->sts_sensedata.es_add_code = 0x21;
2901 arqstat->sts_sensedata.es_qual_code = 0x00;
2902
2903 break;
2904
2905 default:
2906 con_log(CL_ANN, (CE_CONT, "Unknown status!"));
2907 pkt->pkt_reason = CMD_TRAN_ERR;
2908
2909 break;
2910 }
2911
2912 atomic_add_16(&instance->fw_outstanding, (-1));
2913
2914 return_mfi_pkt(instance, cmd);
2915
2916 (void) megasas_common_check(instance, cmd);
2917
2918 if (acmd->cmd_dmahandle) {
2919 if (megasas_check_dma_handle(
2920 acmd->cmd_dmahandle) != DDI_SUCCESS) {
2921 ddi_fm_service_impact(instance->dip,
2922 DDI_SERVICE_UNAFFECTED);
2923 pkt->pkt_reason = CMD_TRAN_ERR;
2924 pkt->pkt_statistics = 0;
2925 }
2926 }
2927
2928 /* Call the callback routine */
2929 if ((pkt->pkt_flags & FLAG_NOINTR) == 0) {
2930 scsi_hba_pkt_comp(pkt);
2931 }
2932
2933 break;
2934 case MFI_CMD_OP_SMP:
2935 case MFI_CMD_OP_STP:
2936 complete_cmd_in_sync_mode(instance, cmd);
2937 break;
2938 case MFI_CMD_OP_DCMD:
2939 /* see if got an event notification */
2940 if (cmd->frame->dcmd.opcode ==
2941 MR_DCMD_CTRL_EVENT_WAIT) {
2942 if ((instance->aen_cmd == cmd) &&
2943 (instance->aen_cmd->abort_aen)) {
2944 con_log(CL_ANN, (CE_WARN,
2945 "megasas_softintr: "
2946 "aborted_aen returned"));
2947 } else {
2948 service_mfi_aen(instance, cmd);
2949
2950 atomic_add_16(&instance->fw_outstanding,
2951 (-1));
2952 }
2953 } else {
2954 complete_cmd_in_sync_mode(instance, cmd);
2955 }
2956
2957 break;
2958 case MFI_CMD_OP_ABORT:
2959 con_log(CL_ANN, (CE_WARN, "MFI_CMD_OP_ABORT complete"));
2960 /*
2961 * MFI_CMD_OP_ABORT successfully completed
2962 * in the synchronous mode
2963 */
2964 complete_cmd_in_sync_mode(instance, cmd);
2965 break;
2966 default:
2967 megasas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
2968 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
2969
2970 if (cmd->pkt != NULL) {
2971 pkt = cmd->pkt;
2972 if ((pkt->pkt_flags & FLAG_NOINTR) == 0) {
2973 scsi_hba_pkt_comp(pkt);
2974 }
2975 }
2976 con_log(CL_ANN, (CE_WARN, "Cmd type unknown !!"));
2977 break;
2978 }
2979 }
2980
2981 instance->softint_running = 0;
2982
2983 return (DDI_INTR_CLAIMED);
2984 }
2985
2986 /*
2987 * mega_alloc_dma_obj
2988 *
2989 * Allocate the memory and other resources for an dma object.
2990 */
2991 static int
2992 mega_alloc_dma_obj(struct megasas_instance *instance, dma_obj_t *obj)
2993 {
2994 int i;
2995 size_t alen = 0;
2996 uint_t cookie_cnt;
2997 struct ddi_device_acc_attr tmp_endian_attr;
2998
2999 tmp_endian_attr = endian_attr;
3000 tmp_endian_attr.devacc_attr_access = DDI_DEFAULT_ACC;
3001 i = ddi_dma_alloc_handle(instance->dip, &obj->dma_attr,
3002 DDI_DMA_SLEEP, NULL, &obj->dma_handle);
3003 if (i != DDI_SUCCESS) {
3004
3005 switch (i) {
3006 case DDI_DMA_BADATTR :
3007 con_log(CL_ANN, (CE_WARN,
3008 "Failed ddi_dma_alloc_handle- Bad atrib"));
3009 break;
3010 case DDI_DMA_NORESOURCES :
3011 con_log(CL_ANN, (CE_WARN,
3012 "Failed ddi_dma_alloc_handle- No Resources"));
3013 break;
3014 default :
3015 con_log(CL_ANN, (CE_WARN,
3016 "Failed ddi_dma_alloc_handle :unknown %d", i));
3017 break;
3018 }
3019
3020 return (-1);
3021 }
3022
3023 if ((ddi_dma_mem_alloc(obj->dma_handle, obj->size, &tmp_endian_attr,
3024 DDI_DMA_RDWR | DDI_DMA_STREAMING, DDI_DMA_SLEEP, NULL,
3025 &obj->buffer, &alen, &obj->acc_handle) != DDI_SUCCESS) ||
3026 alen < obj->size) {
3027
3028 ddi_dma_free_handle(&obj->dma_handle);
3029
3030 con_log(CL_ANN, (CE_WARN, "Failed : ddi_dma_mem_alloc"));
3031
3032 return (-1);
3033 }
3034
3035 if (ddi_dma_addr_bind_handle(obj->dma_handle, NULL, obj->buffer,
3036 obj->size, DDI_DMA_RDWR | DDI_DMA_STREAMING, DDI_DMA_SLEEP,
3037 NULL, &obj->dma_cookie[0], &cookie_cnt) != DDI_SUCCESS) {
3038
3039 ddi_dma_mem_free(&obj->acc_handle);
3040 ddi_dma_free_handle(&obj->dma_handle);
3041
3042 con_log(CL_ANN, (CE_WARN, "Failed : ddi_dma_addr_bind_handle"));
3043
3044 return (-1);
3045 }
3046
3047 if (megasas_check_dma_handle(obj->dma_handle) != DDI_SUCCESS) {
3048 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
3049 return (-1);
3050 }
3051
3052 if (megasas_check_acc_handle(obj->acc_handle) != DDI_SUCCESS) {
3053 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
3054 return (-1);
3055 }
3056
3057 return (cookie_cnt);
3058 }
3059
3060 /*
3061 * mega_free_dma_obj(struct megasas_instance *, dma_obj_t)
3062 *
3063 * De-allocate the memory and other resources for an dma object, which must
3064 * have been alloated by a previous call to mega_alloc_dma_obj()
3065 */
3066 static int
3067 mega_free_dma_obj(struct megasas_instance *instance, dma_obj_t obj)
3068 {
3069
3070 if (megasas_check_dma_handle(obj.dma_handle) != DDI_SUCCESS) {
3071 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
3072 return (DDI_FAILURE);
3073 }
3074
3075 if (megasas_check_acc_handle(obj.acc_handle) != DDI_SUCCESS) {
3076 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
3077 return (DDI_FAILURE);
3078 }
3079
3080 (void) ddi_dma_unbind_handle(obj.dma_handle);
3081 ddi_dma_mem_free(&obj.acc_handle);
3082 ddi_dma_free_handle(&obj.dma_handle);
3083
3084 return (DDI_SUCCESS);
3085 }
3086
3087 /*
3088 * megasas_dma_alloc(instance_t *, struct scsi_pkt *, struct buf *,
3089 * int, int (*)())
3090 *
3091 * Allocate dma resources for a new scsi command
3092 */
3093 static int
3094 megasas_dma_alloc(struct megasas_instance *instance, struct scsi_pkt *pkt,
3095 struct buf *bp, int flags, int (*callback)())
3096 {
3097 int dma_flags;
3098 int (*cb)(caddr_t);
3099 int i;
3100
3101 ddi_dma_attr_t tmp_dma_attr = megasas_generic_dma_attr;
3102 struct scsa_cmd *acmd = PKT2CMD(pkt);
3103
3104 acmd->cmd_buf = bp;
3105
3106 if (bp->b_flags & B_READ) {
3107 acmd->cmd_flags &= ~CFLAG_DMASEND;
3108 dma_flags = DDI_DMA_READ;
3109 } else {
3110 acmd->cmd_flags |= CFLAG_DMASEND;
3111 dma_flags = DDI_DMA_WRITE;
3112 }
3113
3114 if (flags & PKT_CONSISTENT) {
3115 acmd->cmd_flags |= CFLAG_CONSISTENT;
3116 dma_flags |= DDI_DMA_CONSISTENT;
3117 }
3118
3119 if (flags & PKT_DMA_PARTIAL) {
3120 dma_flags |= DDI_DMA_PARTIAL;
3121 }
3122
3123 dma_flags |= DDI_DMA_REDZONE;
3124
3125 cb = (callback == NULL_FUNC) ? DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;
3126
3127 tmp_dma_attr.dma_attr_sgllen = instance->max_num_sge;
3128 tmp_dma_attr.dma_attr_addr_hi = 0xffffffffffffffffull;
3129
3130 if ((i = ddi_dma_alloc_handle(instance->dip, &tmp_dma_attr,
3131 cb, 0, &acmd->cmd_dmahandle)) != DDI_SUCCESS) {
3132 switch (i) {
3133 case DDI_DMA_BADATTR:
3134 bioerror(bp, EFAULT);
3135 return (-1);
3136
3137 case DDI_DMA_NORESOURCES:
3138 bioerror(bp, 0);
3139 return (-1);
3140
3141 default:
3142 con_log(CL_ANN, (CE_PANIC, "ddi_dma_alloc_handle: "
3143 "0x%x impossible\n", i));
3144 bioerror(bp, EFAULT);
3145 return (-1);
3146 }
3147 }
3148
3149 i = ddi_dma_buf_bind_handle(acmd->cmd_dmahandle, bp, dma_flags,
3150 cb, 0, &acmd->cmd_dmacookies[0], &acmd->cmd_ncookies);
3151
3152 switch (i) {
3153 case DDI_DMA_PARTIAL_MAP:
3154 if ((dma_flags & DDI_DMA_PARTIAL) == 0) {
3155 con_log(CL_ANN, (CE_PANIC, "ddi_dma_buf_bind_handle: "
3156 "DDI_DMA_PARTIAL_MAP impossible\n"));
3157 goto no_dma_cookies;
3158 }
3159
3160 if (ddi_dma_numwin(acmd->cmd_dmahandle, &acmd->cmd_nwin) ==
3161 DDI_FAILURE) {
3162 con_log(CL_ANN, (CE_PANIC, "ddi_dma_numwin failed\n"));
3163 goto no_dma_cookies;
3164 }
3165
3166 if (ddi_dma_getwin(acmd->cmd_dmahandle, acmd->cmd_curwin,
3167 &acmd->cmd_dma_offset, &acmd->cmd_dma_len,
3168 &acmd->cmd_dmacookies[0], &acmd->cmd_ncookies) ==
3169 DDI_FAILURE) {
3170
3171 con_log(CL_ANN, (CE_PANIC, "ddi_dma_getwin failed\n"));
3172 goto no_dma_cookies;
3173 }
3174
3175 goto get_dma_cookies;
3176 case DDI_DMA_MAPPED:
3177 acmd->cmd_nwin = 1;
3178 acmd->cmd_dma_len = 0;
3179 acmd->cmd_dma_offset = 0;
3180
3181 get_dma_cookies:
3182 i = 0;
3183 acmd->cmd_dmacount = 0;
3184 for (;;) {
3185 acmd->cmd_dmacount +=
3186 acmd->cmd_dmacookies[i++].dmac_size;
3187
3188 if (i == instance->max_num_sge ||
3189 i == acmd->cmd_ncookies)
3190 break;
3191
3192 ddi_dma_nextcookie(acmd->cmd_dmahandle,
3193 &acmd->cmd_dmacookies[i]);
3194 }
3195
3196 acmd->cmd_cookie = i;
3197 acmd->cmd_cookiecnt = i;
3198
3199 acmd->cmd_flags |= CFLAG_DMAVALID;
3200
3201 if (bp->b_bcount >= acmd->cmd_dmacount) {
3202 pkt->pkt_resid = bp->b_bcount - acmd->cmd_dmacount;
3203 } else {
3204 pkt->pkt_resid = 0;
3205 }
3206
3207 return (0);
3208 case DDI_DMA_NORESOURCES:
3209 bioerror(bp, 0);
3210 break;
3211 case DDI_DMA_NOMAPPING:
3212 bioerror(bp, EFAULT);
3213 break;
3214 case DDI_DMA_TOOBIG:
3215 bioerror(bp, EINVAL);
3216 break;
3217 case DDI_DMA_INUSE:
3218 con_log(CL_ANN, (CE_PANIC, "ddi_dma_buf_bind_handle:"
3219 " DDI_DMA_INUSE impossible\n"));
3220 break;
3221 default:
3222 con_log(CL_ANN, (CE_PANIC, "ddi_dma_buf_bind_handle: "
3223 "0x%x impossible\n", i));
3224 break;
3225 }
3226
3227 no_dma_cookies:
3228 ddi_dma_free_handle(&acmd->cmd_dmahandle);
3229 acmd->cmd_dmahandle = NULL;
3230 acmd->cmd_flags &= ~CFLAG_DMAVALID;
3231 return (-1);
3232 }
3233
3234 /*
3235 * megasas_dma_move(struct megasas_instance *, struct scsi_pkt *, struct buf *)
3236 *
3237 * move dma resources to next dma window
3238 *
3239 */
3240 static int
3241 megasas_dma_move(struct megasas_instance *instance, struct scsi_pkt *pkt,
3242 struct buf *bp)
3243 {
3244 int i = 0;
3245
3246 struct scsa_cmd *acmd = PKT2CMD(pkt);
3247
3248 /*
3249 * If there are no more cookies remaining in this window,
3250 * must move to the next window first.
3251 */
3252 if (acmd->cmd_cookie == acmd->cmd_ncookies) {
3253 if (acmd->cmd_curwin == acmd->cmd_nwin && acmd->cmd_nwin == 1) {
3254 return (0);
3255 }
3256
3257 /* at last window, cannot move */
3258 if (++acmd->cmd_curwin >= acmd->cmd_nwin) {
3259 return (-1);
3260 }
3261
3262 if (ddi_dma_getwin(acmd->cmd_dmahandle, acmd->cmd_curwin,
3263 &acmd->cmd_dma_offset, &acmd->cmd_dma_len,
3264 &acmd->cmd_dmacookies[0], &acmd->cmd_ncookies) ==
3265 DDI_FAILURE) {
3266 return (-1);
3267 }
3268
3269 acmd->cmd_cookie = 0;
3270 } else {
3271 /* still more cookies in this window - get the next one */
3272 ddi_dma_nextcookie(acmd->cmd_dmahandle,
3273 &acmd->cmd_dmacookies[0]);
3274 }
3275
3276 /* get remaining cookies in this window, up to our maximum */
3277 for (;;) {
3278 acmd->cmd_dmacount += acmd->cmd_dmacookies[i++].dmac_size;
3279 acmd->cmd_cookie++;
3280
3281 if (i == instance->max_num_sge ||
3282 acmd->cmd_cookie == acmd->cmd_ncookies) {
3283 break;
3284 }
3285
3286 ddi_dma_nextcookie(acmd->cmd_dmahandle,
3287 &acmd->cmd_dmacookies[i]);
3288 }
3289
3290 acmd->cmd_cookiecnt = i;
3291
3292 if (bp->b_bcount >= acmd->cmd_dmacount) {
3293 pkt->pkt_resid = bp->b_bcount - acmd->cmd_dmacount;
3294 } else {
3295 pkt->pkt_resid = 0;
3296 }
3297
3298 return (0);
3299 }
3300
3301 /*
3302 * build_cmd
3303 */
3304 static struct megasas_cmd *
3305 build_cmd(struct megasas_instance *instance, struct scsi_address *ap,
3306 struct scsi_pkt *pkt, uchar_t *cmd_done)
3307 {
3308 uint16_t flags = 0;
3309 uint32_t i;
3310 uint32_t context;
3311 uint32_t sge_bytes;
3312
3313 struct megasas_cmd *cmd;
3314 struct megasas_sge64 *mfi_sgl;
3315 struct scsa_cmd *acmd = PKT2CMD(pkt);
3316 struct megasas_pthru_frame *pthru;
3317 struct megasas_io_frame *ldio;
3318
3319 /* find out if this is logical or physical drive command. */
3320 acmd->islogical = MEGADRV_IS_LOGICAL(ap);
3321 acmd->device_id = MAP_DEVICE_ID(instance, ap);
3322 *cmd_done = 0;
3323
3324 /* get the command packet */
3325 if (!(cmd = get_mfi_pkt(instance))) {
3326 return (NULL);
3327 }
3328
3329 cmd->pkt = pkt;
3330 cmd->cmd = acmd;
3331
3332 /* lets get the command directions */
3333 if (acmd->cmd_flags & CFLAG_DMASEND) {
3334 flags = MFI_FRAME_DIR_WRITE;
3335
3336 if (acmd->cmd_flags & CFLAG_CONSISTENT) {
3337 (void) ddi_dma_sync(acmd->cmd_dmahandle,
3338 acmd->cmd_dma_offset, acmd->cmd_dma_len,
3339 DDI_DMA_SYNC_FORDEV);
3340 }
3341 } else if (acmd->cmd_flags & ~CFLAG_DMASEND) {
3342 flags = MFI_FRAME_DIR_READ;
3343
3344 if (acmd->cmd_flags & CFLAG_CONSISTENT) {
3345 (void) ddi_dma_sync(acmd->cmd_dmahandle,
3346 acmd->cmd_dma_offset, acmd->cmd_dma_len,
3347 DDI_DMA_SYNC_FORCPU);
3348 }
3349 } else {
3350 flags = MFI_FRAME_DIR_NONE;
3351 }
3352
3353 flags |= MFI_FRAME_SGL64;
3354
3355 switch (pkt->pkt_cdbp[0]) {
3356
3357 /*
3358 * case SCMD_SYNCHRONIZE_CACHE:
3359 * flush_cache(instance);
3360 * return_mfi_pkt(instance, cmd);
3361 * *cmd_done = 1;
3362 *
3363 * return (NULL);
3364 */
3365
3366 case SCMD_READ:
3367 case SCMD_WRITE:
3368 case SCMD_READ_G1:
3369 case SCMD_WRITE_G1:
3370 if (acmd->islogical) {
3371 ldio = (struct megasas_io_frame *)cmd->frame;
3372
3373 /*
3374 * preare the Logical IO frame:
3375 * 2nd bit is zero for all read cmds
3376 */
3377 ldio->cmd = (pkt->pkt_cdbp[0] & 0x02) ?
3378 MFI_CMD_OP_LD_WRITE : MFI_CMD_OP_LD_READ;
3379 ldio->cmd_status = 0x0;
3380 ldio->scsi_status = 0x0;
3381 ldio->target_id = acmd->device_id;
3382 ldio->timeout = 0;
3383 ldio->reserved_0 = 0;
3384 ldio->pad_0 = 0;
3385 ldio->flags = flags;
3386
3387 /* Initialize sense Information */
3388 bzero(cmd->sense, SENSE_LENGTH);
3389 ldio->sense_len = SENSE_LENGTH;
3390 ldio->sense_buf_phys_addr_hi = 0;
3391 ldio->sense_buf_phys_addr_lo = cmd->sense_phys_addr;
3392
3393 ldio->start_lba_hi = 0;
3394 ldio->access_byte = (acmd->cmd_cdblen != 6) ?
3395 pkt->pkt_cdbp[1] : 0;
3396 ldio->sge_count = acmd->cmd_cookiecnt;
3397 mfi_sgl = (struct megasas_sge64 *)&ldio->sgl;
3398
3399 context = ldio->context;
3400
3401 if (acmd->cmd_cdblen == CDB_GROUP0) {
3402 ldio->lba_count = host_to_le16(
3403 (uint16_t)(pkt->pkt_cdbp[4]));
3404
3405 ldio->start_lba_lo = host_to_le32(
3406 ((uint32_t)(pkt->pkt_cdbp[3])) |
3407 ((uint32_t)(pkt->pkt_cdbp[2]) << 8) |
3408 ((uint32_t)((pkt->pkt_cdbp[1]) & 0x1F)
3409 << 16));
3410 } else if (acmd->cmd_cdblen == CDB_GROUP1) {
3411 ldio->lba_count = host_to_le16(
3412 ((uint16_t)(pkt->pkt_cdbp[8])) |
3413 ((uint16_t)(pkt->pkt_cdbp[7]) << 8));
3414
3415 ldio->start_lba_lo = host_to_le32(
3416 ((uint32_t)(pkt->pkt_cdbp[5])) |
3417 ((uint32_t)(pkt->pkt_cdbp[4]) << 8) |
3418 ((uint32_t)(pkt->pkt_cdbp[3]) << 16) |
3419 ((uint32_t)(pkt->pkt_cdbp[2]) << 24));
3420 } else if (acmd->cmd_cdblen == CDB_GROUP2) {
3421 ldio->lba_count = host_to_le16(
3422 ((uint16_t)(pkt->pkt_cdbp[9])) |
3423 ((uint16_t)(pkt->pkt_cdbp[8]) << 8) |
3424 ((uint16_t)(pkt->pkt_cdbp[7]) << 16) |
3425 ((uint16_t)(pkt->pkt_cdbp[6]) << 24));
3426
3427 ldio->start_lba_lo = host_to_le32(
3428 ((uint32_t)(pkt->pkt_cdbp[5])) |
3429 ((uint32_t)(pkt->pkt_cdbp[4]) << 8) |
3430 ((uint32_t)(pkt->pkt_cdbp[3]) << 16) |
3431 ((uint32_t)(pkt->pkt_cdbp[2]) << 24));
3432 } else if (acmd->cmd_cdblen == CDB_GROUP3) {
3433 ldio->lba_count = host_to_le16(
3434 ((uint16_t)(pkt->pkt_cdbp[13])) |
3435 ((uint16_t)(pkt->pkt_cdbp[12]) << 8) |
3436 ((uint16_t)(pkt->pkt_cdbp[11]) << 16) |
3437 ((uint16_t)(pkt->pkt_cdbp[10]) << 24));
3438
3439 ldio->start_lba_lo = host_to_le32(
3440 ((uint32_t)(pkt->pkt_cdbp[9])) |
3441 ((uint32_t)(pkt->pkt_cdbp[8]) << 8) |
3442 ((uint32_t)(pkt->pkt_cdbp[7]) << 16) |
3443 ((uint32_t)(pkt->pkt_cdbp[6]) << 24));
3444
3445 ldio->start_lba_lo = host_to_le32(
3446 ((uint32_t)(pkt->pkt_cdbp[5])) |
3447 ((uint32_t)(pkt->pkt_cdbp[4]) << 8) |
3448 ((uint32_t)(pkt->pkt_cdbp[3]) << 16) |
3449 ((uint32_t)(pkt->pkt_cdbp[2]) << 24));
3450 }
3451
3452 break;
3453 }
3454 /* fall through For all non-rd/wr cmds */
3455 default:
3456 pthru = (struct megasas_pthru_frame *)cmd->frame;
3457
3458 /* prepare the DCDB frame */
3459 pthru->cmd = (acmd->islogical) ?
3460 MFI_CMD_OP_LD_SCSI : MFI_CMD_OP_PD_SCSI;
3461 pthru->cmd_status = 0x0;
3462 pthru->scsi_status = 0x0;
3463 pthru->target_id = acmd->device_id;
3464 pthru->lun = 0;
3465 pthru->cdb_len = acmd->cmd_cdblen;
3466 pthru->timeout = 0;
3467 pthru->flags = flags;
3468 pthru->data_xfer_len = acmd->cmd_dmacount;
3469 pthru->sge_count = acmd->cmd_cookiecnt;
3470 mfi_sgl = (struct megasas_sge64 *)&pthru->sgl;
3471
3472 bzero(cmd->sense, SENSE_LENGTH);
3473 pthru->sense_len = SENSE_LENGTH;
3474 pthru->sense_buf_phys_addr_hi = 0;
3475 pthru->sense_buf_phys_addr_lo = cmd->sense_phys_addr;
3476
3477 context = pthru->context;
3478
3479 bcopy(pkt->pkt_cdbp, pthru->cdb, acmd->cmd_cdblen);
3480
3481 break;
3482 }
3483 #ifdef lint
3484 context = context;
3485 #endif
3486 /* bzero(mfi_sgl, sizeof (struct megasas_sge64) * MAX_SGL); */
3487
3488 /* prepare the scatter-gather list for the firmware */
3489 for (i = 0; i < acmd->cmd_cookiecnt; i++, mfi_sgl++) {
3490 mfi_sgl->phys_addr = acmd->cmd_dmacookies[i].dmac_laddress;
3491 mfi_sgl->length = acmd->cmd_dmacookies[i].dmac_size;
3492 }
3493
3494 sge_bytes = sizeof (struct megasas_sge64)*acmd->cmd_cookiecnt;
3495
3496 cmd->frame_count = (sge_bytes / MEGAMFI_FRAME_SIZE) +
3497 ((sge_bytes % MEGAMFI_FRAME_SIZE) ? 1 : 0) + 1;
3498
3499 if (cmd->frame_count >= 8) {
3500 cmd->frame_count = 8;
3501 }
3502
3503 return (cmd);
3504 }
3505
3506 /*
3507 * wait_for_outstanding - Wait for all outstanding cmds
3508 * @instance: Adapter soft state
3509 *
3510 * This function waits for upto MEGASAS_RESET_WAIT_TIME seconds for FW to
3511 * complete all its outstanding commands. Returns error if one or more IOs
3512 * are pending after this time period.
3513 */
3514 static int
3515 wait_for_outstanding(struct megasas_instance *instance)
3516 {
3517 int i;
3518 uint32_t wait_time = 90;
3519
3520 for (i = 0; i < wait_time; i++) {
3521 if (!instance->fw_outstanding) {
3522 break;
3523 }
3524
3525 drv_usecwait(MILLISEC); /* wait for 1000 usecs */;
3526 }
3527
3528 if (instance->fw_outstanding) {
3529 return (1);
3530 }
3531
3532 ddi_fm_acc_err_clear(instance->regmap_handle, DDI_FME_VERSION);
3533
3534 return (0);
3535 }
3536
3537 /*
3538 * issue_mfi_pthru
3539 */
3540 static int
3541 issue_mfi_pthru(struct megasas_instance *instance, struct megasas_ioctl *ioctl,
3542 struct megasas_cmd *cmd, int mode)
3543 {
3544 void *ubuf;
3545 uint32_t kphys_addr = 0;
3546 uint32_t xferlen = 0;
3547 uint_t model;
3548
3549 dma_obj_t pthru_dma_obj;
3550 struct megasas_pthru_frame *kpthru;
3551 struct megasas_pthru_frame *pthru;
3552
3553 pthru = &cmd->frame->pthru;
3554 kpthru = (struct megasas_pthru_frame *)&ioctl->frame[0];
3555
3556 model = ddi_model_convert_from(mode & FMODELS);
3557 if (model == DDI_MODEL_ILP32) {
3558 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_pthru: DDI_MODEL_LP32"));
3559
3560 xferlen = kpthru->sgl.sge32[0].length;
3561
3562 /* SJ! - ubuf needs to be virtual address. */
3563 ubuf = (void *)(ulong_t)kpthru->sgl.sge32[0].phys_addr;
3564 } else {
3565 #ifdef _ILP32
3566 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_pthru: DDI_MODEL_LP32"));
3567 xferlen = kpthru->sgl.sge32[0].length;
3568 /* SJ! - ubuf needs to be virtual address. */
3569 ubuf = (void *)(ulong_t)kpthru->sgl.sge32[0].phys_addr;
3570 #else
3571 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_pthru: DDI_MODEL_LP64"));
3572 xferlen = kpthru->sgl.sge64[0].length;
3573 /* SJ! - ubuf needs to be virtual address. */
3574 ubuf = (void *)(ulong_t)kpthru->sgl.sge64[0].phys_addr;
3575 #endif
3576 }
3577
3578 if (xferlen) {
3579 /* means IOCTL requires DMA */
3580 /* allocate the data transfer buffer */
3581 pthru_dma_obj.size = xferlen;
3582 pthru_dma_obj.dma_attr = megasas_generic_dma_attr;
3583 pthru_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
3584 pthru_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
3585 pthru_dma_obj.dma_attr.dma_attr_sgllen = 1;
3586 pthru_dma_obj.dma_attr.dma_attr_align = 1;
3587
3588 /* allocate kernel buffer for DMA */
3589 if (mega_alloc_dma_obj(instance, &pthru_dma_obj) != 1) {
3590 con_log(CL_ANN, (CE_WARN, "issue_mfi_pthru: "
3591 "could not data transfer buffer alloc."));
3592 return (DDI_FAILURE);
3593 }
3594
3595 /* If IOCTL requires DMA WRITE, do ddi_copyin IOCTL data copy */
3596 if (kpthru->flags & MFI_FRAME_DIR_WRITE) {
3597 if (ddi_copyin(ubuf, (void *)pthru_dma_obj.buffer,
3598 xferlen, mode)) {
3599 con_log(CL_ANN, (CE_WARN, "issue_mfi_pthru: "
3600 "copy from user space failed\n"));
3601 return (1);
3602 }
3603 }
3604
3605 kphys_addr = pthru_dma_obj.dma_cookie[0].dmac_address;
3606 }
3607
3608 pthru->cmd = kpthru->cmd;
3609 pthru->sense_len = kpthru->sense_len;
3610 pthru->cmd_status = kpthru->cmd_status;
3611 pthru->scsi_status = kpthru->scsi_status;
3612 pthru->target_id = kpthru->target_id;
3613 pthru->lun = kpthru->lun;
3614 pthru->cdb_len = kpthru->cdb_len;
3615 pthru->sge_count = kpthru->sge_count;
3616 pthru->timeout = kpthru->timeout;
3617 pthru->data_xfer_len = kpthru->data_xfer_len;
3618
3619 pthru->sense_buf_phys_addr_hi = 0;
3620 /* pthru->sense_buf_phys_addr_lo = cmd->sense_phys_addr; */
3621 pthru->sense_buf_phys_addr_lo = 0;
3622
3623 bcopy((void *)kpthru->cdb, (void *)pthru->cdb, pthru->cdb_len);
3624
3625 pthru->flags = kpthru->flags & ~MFI_FRAME_SGL64;
3626 pthru->sgl.sge32[0].length = xferlen;
3627 pthru->sgl.sge32[0].phys_addr = kphys_addr;
3628
3629 cmd->sync_cmd = MEGASAS_TRUE;
3630 cmd->frame_count = 1;
3631
3632 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
3633 con_log(CL_ANN, (CE_WARN,
3634 "issue_mfi_pthru: fw_ioctl failed\n"));
3635 } else {
3636 if (xferlen && (kpthru->flags & MFI_FRAME_DIR_READ)) {
3637
3638 if (ddi_copyout(pthru_dma_obj.buffer, ubuf,
3639 xferlen, mode)) {
3640 con_log(CL_ANN, (CE_WARN, "issue_mfi_pthru: "
3641 "copy to user space failed\n"));
3642 return (1);
3643 }
3644 }
3645 }
3646
3647 kpthru->cmd_status = pthru->cmd_status;
3648 kpthru->scsi_status = pthru->scsi_status;
3649
3650 con_log(CL_ANN, (CE_NOTE, "issue_mfi_pthru: cmd_status %x, "
3651 "scsi_status %x\n", pthru->cmd_status, pthru->scsi_status));
3652
3653 if (xferlen) {
3654 /* free kernel buffer */
3655 if (mega_free_dma_obj(instance, pthru_dma_obj) != DDI_SUCCESS)
3656 return (1);
3657 }
3658
3659 return (0);
3660 }
3661
3662 /*
3663 * issue_mfi_dcmd
3664 */
3665 static int
3666 issue_mfi_dcmd(struct megasas_instance *instance, struct megasas_ioctl *ioctl,
3667 struct megasas_cmd *cmd, int mode)
3668 {
3669 void *ubuf;
3670 uint32_t kphys_addr = 0;
3671 uint32_t xferlen = 0;
3672 uint32_t model;
3673 dma_obj_t dcmd_dma_obj;
3674 struct megasas_dcmd_frame *kdcmd;
3675 struct megasas_dcmd_frame *dcmd;
3676
3677 dcmd = &cmd->frame->dcmd;
3678 kdcmd = (struct megasas_dcmd_frame *)&ioctl->frame[0];
3679
3680 model = ddi_model_convert_from(mode & FMODELS);
3681 if (model == DDI_MODEL_ILP32) {
3682 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_dcmd: DDI_MODEL_ILP32"));
3683
3684 xferlen = kdcmd->sgl.sge32[0].length;
3685
3686 /* SJ! - ubuf needs to be virtual address. */
3687 ubuf = (void *)(ulong_t)kdcmd->sgl.sge32[0].phys_addr;
3688 }
3689 else
3690 {
3691 #ifdef _ILP32
3692 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_dcmd: DDI_MODEL_ILP32"));
3693 xferlen = kdcmd->sgl.sge32[0].length;
3694 /* SJ! - ubuf needs to be virtual address. */
3695 ubuf = (void *)(ulong_t)kdcmd->sgl.sge32[0].phys_addr;
3696 #else
3697 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_dcmd: DDI_MODEL_LP64"));
3698 xferlen = kdcmd->sgl.sge64[0].length;
3699 /* SJ! - ubuf needs to be virtual address. */
3700 ubuf = (void *)(ulong_t)dcmd->sgl.sge64[0].phys_addr;
3701 #endif
3702 }
3703 if (xferlen) {
3704 /* means IOCTL requires DMA */
3705 /* allocate the data transfer buffer */
3706 dcmd_dma_obj.size = xferlen;
3707 dcmd_dma_obj.dma_attr = megasas_generic_dma_attr;
3708 dcmd_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
3709 dcmd_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
3710 dcmd_dma_obj.dma_attr.dma_attr_sgllen = 1;
3711 dcmd_dma_obj.dma_attr.dma_attr_align = 1;
3712
3713 /* allocate kernel buffer for DMA */
3714 if (mega_alloc_dma_obj(instance, &dcmd_dma_obj) != 1) {
3715 con_log(CL_ANN, (CE_WARN, "issue_mfi_dcmd: "
3716 "could not data transfer buffer alloc."));
3717 return (DDI_FAILURE);
3718 }
3719
3720 /* If IOCTL requires DMA WRITE, do ddi_copyin IOCTL data copy */
3721 if (kdcmd->flags & MFI_FRAME_DIR_WRITE) {
3722 if (ddi_copyin(ubuf, (void *)dcmd_dma_obj.buffer,
3723 xferlen, mode)) {
3724 con_log(CL_ANN, (CE_WARN, "issue_mfi_dcmd: "
3725 "copy from user space failed\n"));
3726 return (1);
3727 }
3728 }
3729
3730 kphys_addr = dcmd_dma_obj.dma_cookie[0].dmac_address;
3731 }
3732
3733 dcmd->cmd = kdcmd->cmd;
3734 dcmd->cmd_status = kdcmd->cmd_status;
3735 dcmd->sge_count = kdcmd->sge_count;
3736 dcmd->timeout = kdcmd->timeout;
3737 dcmd->data_xfer_len = kdcmd->data_xfer_len;
3738 dcmd->opcode = kdcmd->opcode;
3739
3740 bcopy((void *)kdcmd->mbox.b, (void *)dcmd->mbox.b, DCMD_MBOX_SZ);
3741
3742 dcmd->flags = kdcmd->flags & ~MFI_FRAME_SGL64;
3743 dcmd->sgl.sge32[0].length = xferlen;
3744 dcmd->sgl.sge32[0].phys_addr = kphys_addr;
3745
3746 cmd->sync_cmd = MEGASAS_TRUE;
3747 cmd->frame_count = 1;
3748
3749 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
3750 con_log(CL_ANN, (CE_WARN, "issue_mfi_dcmd: fw_ioctl failed\n"));
3751 } else {
3752 if (xferlen && (kdcmd->flags & MFI_FRAME_DIR_READ)) {
3753
3754 if (ddi_copyout(dcmd_dma_obj.buffer, ubuf,
3755 xferlen, mode)) {
3756 con_log(CL_ANN, (CE_WARN, "issue_mfi_dcmd: "
3757 "copy to user space failed\n"));
3758 return (1);
3759 }
3760 }
3761 }
3762
3763 kdcmd->cmd_status = dcmd->cmd_status;
3764
3765 if (xferlen) {
3766 /* free kernel buffer */
3767 if (mega_free_dma_obj(instance, dcmd_dma_obj) != DDI_SUCCESS)
3768 return (1);
3769 }
3770
3771 return (0);
3772 }
3773
3774 /*
3775 * issue_mfi_smp
3776 */
3777 static int
3778 issue_mfi_smp(struct megasas_instance *instance, struct megasas_ioctl *ioctl,
3779 struct megasas_cmd *cmd, int mode)
3780 {
3781 void *request_ubuf;
3782 void *response_ubuf;
3783 uint32_t request_xferlen = 0;
3784 uint32_t response_xferlen = 0;
3785 uint_t model;
3786 dma_obj_t request_dma_obj;
3787 dma_obj_t response_dma_obj;
3788 struct megasas_smp_frame *ksmp;
3789 struct megasas_smp_frame *smp;
3790 struct megasas_sge32 *sge32;
3791 #ifndef _ILP32
3792 struct megasas_sge64 *sge64;
3793 #endif
3794
3795 smp = &cmd->frame->smp;
3796 ksmp = (struct megasas_smp_frame *)&ioctl->frame[0];
3797
3798 model = ddi_model_convert_from(mode & FMODELS);
3799 if (model == DDI_MODEL_ILP32) {
3800 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_smp: DDI_MODEL_ILP32"));
3801
3802 sge32 = &ksmp->sgl[0].sge32[0];
3803 response_xferlen = sge32[0].length;
3804 request_xferlen = sge32[1].length;
3805 con_log(CL_ANN, (CE_NOTE, "issue_mfi_smp: "
3806 "response_xferlen = %x, request_xferlen = %x",
3807 response_xferlen, request_xferlen));
3808
3809 /* SJ! - ubuf needs to be virtual address. */
3810
3811 response_ubuf = (void *)(ulong_t)sge32[0].phys_addr;
3812 request_ubuf = (void *)(ulong_t)sge32[1].phys_addr;
3813 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_smp: "
3814 "response_ubuf = %p, request_ubuf = %p",
3815 response_ubuf, request_ubuf));
3816 } else {
3817 #ifdef _ILP32
3818 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_smp: DDI_MODEL_ILP32"));
3819
3820 sge32 = &ksmp->sgl[0].sge32[0];
3821 response_xferlen = sge32[0].length;
3822 request_xferlen = sge32[1].length;
3823 con_log(CL_ANN, (CE_NOTE, "issue_mfi_smp: "
3824 "response_xferlen = %x, request_xferlen = %x",
3825 response_xferlen, request_xferlen));
3826
3827 /* SJ! - ubuf needs to be virtual address. */
3828
3829 response_ubuf = (void *)(ulong_t)sge32[0].phys_addr;
3830 request_ubuf = (void *)(ulong_t)sge32[1].phys_addr;
3831 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_smp: "
3832 "response_ubuf = %p, request_ubuf = %p",
3833 response_ubuf, request_ubuf));
3834 #else
3835 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_smp: DDI_MODEL_LP64"));
3836
3837 sge64 = &ksmp->sgl[0].sge64[0];
3838 response_xferlen = sge64[0].length;
3839 request_xferlen = sge64[1].length;
3840
3841 /* SJ! - ubuf needs to be virtual address. */
3842 response_ubuf = (void *)(ulong_t)sge64[0].phys_addr;
3843 request_ubuf = (void *)(ulong_t)sge64[1].phys_addr;
3844 #endif
3845 }
3846 if (request_xferlen) {
3847 /* means IOCTL requires DMA */
3848 /* allocate the data transfer buffer */
3849 request_dma_obj.size = request_xferlen;
3850 request_dma_obj.dma_attr = megasas_generic_dma_attr;
3851 request_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
3852 request_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
3853 request_dma_obj.dma_attr.dma_attr_sgllen = 1;
3854 request_dma_obj.dma_attr.dma_attr_align = 1;
3855
3856 /* allocate kernel buffer for DMA */
3857 if (mega_alloc_dma_obj(instance, &request_dma_obj) != 1) {
3858 con_log(CL_ANN, (CE_WARN, "issue_mfi_smp: "
3859 "could not data transfer buffer alloc."));
3860 return (DDI_FAILURE);
3861 }
3862
3863 /* If IOCTL requires DMA WRITE, do ddi_copyin IOCTL data copy */
3864 if (ddi_copyin(request_ubuf, (void *) request_dma_obj.buffer,
3865 request_xferlen, mode)) {
3866 con_log(CL_ANN, (CE_WARN, "issue_mfi_smp: "
3867 "copy from user space failed\n"));
3868 return (1);
3869 }
3870 }
3871
3872 if (response_xferlen) {
3873 /* means IOCTL requires DMA */
3874 /* allocate the data transfer buffer */
3875 response_dma_obj.size = response_xferlen;
3876 response_dma_obj.dma_attr = megasas_generic_dma_attr;
3877 response_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
3878 response_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
3879 response_dma_obj.dma_attr.dma_attr_sgllen = 1;
3880 response_dma_obj.dma_attr.dma_attr_align = 1;
3881
3882 /* allocate kernel buffer for DMA */
3883 if (mega_alloc_dma_obj(instance, &response_dma_obj) != 1) {
3884 con_log(CL_ANN, (CE_WARN, "issue_mfi_smp: "
3885 "could not data transfer buffer alloc."));
3886 return (DDI_FAILURE);
3887 }
3888
3889 /* If IOCTL requires DMA WRITE, do ddi_copyin IOCTL data copy */
3890 if (ddi_copyin(response_ubuf, (void *) response_dma_obj.buffer,
3891 response_xferlen, mode)) {
3892 con_log(CL_ANN, (CE_WARN, "issue_mfi_smp: "
3893 "copy from user space failed\n"));
3894 return (1);
3895 }
3896 }
3897
3898 smp->cmd = ksmp->cmd;
3899 smp->cmd_status = ksmp->cmd_status;
3900 smp->connection_status = ksmp->connection_status;
3901 smp->sge_count = ksmp->sge_count;
3902 /* smp->context = ksmp->context; */
3903 smp->timeout = ksmp->timeout;
3904 smp->data_xfer_len = ksmp->data_xfer_len;
3905
3906 bcopy((void *)&ksmp->sas_addr, (void *)&smp->sas_addr,
3907 sizeof (uint64_t));
3908
3909 smp->flags = ksmp->flags & ~MFI_FRAME_SGL64;
3910
3911 model = ddi_model_convert_from(mode & FMODELS);
3912 if (model == DDI_MODEL_ILP32) {
3913 con_log(CL_ANN1, (CE_NOTE,
3914 "handle_drv_ioctl: DDI_MODEL_ILP32"));
3915
3916 sge32 = &smp->sgl[0].sge32[0];
3917 sge32[0].length = response_xferlen;
3918 sge32[0].phys_addr =
3919 response_dma_obj.dma_cookie[0].dmac_address;
3920 sge32[1].length = request_xferlen;
3921 sge32[1].phys_addr =
3922 request_dma_obj.dma_cookie[0].dmac_address;
3923 } else {
3924 #ifdef _ILP32
3925 con_log(CL_ANN1, (CE_NOTE,
3926 "handle_drv_ioctl: DDI_MODEL_ILP32"));
3927 sge32 = &smp->sgl[0].sge32[0];
3928 sge32[0].length = response_xferlen;
3929 sge32[0].phys_addr =
3930 response_dma_obj.dma_cookie[0].dmac_address;
3931 sge32[1].length = request_xferlen;
3932 sge32[1].phys_addr =
3933 request_dma_obj.dma_cookie[0].dmac_address;
3934 #else
3935 con_log(CL_ANN1, (CE_NOTE,
3936 "issue_mfi_smp: DDI_MODEL_LP64"));
3937 sge64 = &smp->sgl[0].sge64[0];
3938 sge64[0].length = response_xferlen;
3939 sge64[0].phys_addr =
3940 response_dma_obj.dma_cookie[0].dmac_address;
3941 sge64[1].length = request_xferlen;
3942 sge64[1].phys_addr =
3943 request_dma_obj.dma_cookie[0].dmac_address;
3944 #endif
3945 }
3946 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_smp: "
3947 "smp->response_xferlen = %d, smp->request_xferlen = %d "
3948 "smp->data_xfer_len = %d", sge32[0].length, sge32[1].length,
3949 smp->data_xfer_len));
3950
3951 cmd->sync_cmd = MEGASAS_TRUE;
3952 cmd->frame_count = 1;
3953
3954 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
3955 con_log(CL_ANN, (CE_WARN,
3956 "issue_mfi_smp: fw_ioctl failed\n"));
3957 } else {
3958 con_log(CL_ANN1, (CE_NOTE,
3959 "issue_mfi_smp: copy to user space\n"));
3960
3961 if (request_xferlen) {
3962 if (ddi_copyout(request_dma_obj.buffer, request_ubuf,
3963 request_xferlen, mode)) {
3964 con_log(CL_ANN, (CE_WARN, "issue_mfi_smp: "
3965 "copy to user space failed\n"));
3966 return (1);
3967 }
3968 }
3969
3970 if (response_xferlen) {
3971 if (ddi_copyout(response_dma_obj.buffer, response_ubuf,
3972 response_xferlen, mode)) {
3973 con_log(CL_ANN, (CE_WARN, "issue_mfi_smp: "
3974 "copy to user space failed\n"));
3975 return (1);
3976 }
3977 }
3978 }
3979
3980 ksmp->cmd_status = smp->cmd_status;
3981 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_smp: smp->cmd_status = %d",
3982 smp->cmd_status));
3983
3984
3985 if (request_xferlen) {
3986 /* free kernel buffer */
3987 if (mega_free_dma_obj(instance, request_dma_obj) != DDI_SUCCESS)
3988 return (1);
3989 }
3990
3991 if (response_xferlen) {
3992 /* free kernel buffer */
3993 if (mega_free_dma_obj(instance, response_dma_obj) !=
3994 DDI_SUCCESS)
3995 return (1);
3996 }
3997
3998 return (0);
3999 }
4000
4001 /*
4002 * issue_mfi_stp
4003 */
4004 static int
4005 issue_mfi_stp(struct megasas_instance *instance, struct megasas_ioctl *ioctl,
4006 struct megasas_cmd *cmd, int mode)
4007 {
4008 void *fis_ubuf;
4009 void *data_ubuf;
4010 uint32_t fis_xferlen = 0;
4011 uint32_t data_xferlen = 0;
4012 uint_t model;
4013 dma_obj_t fis_dma_obj;
4014 dma_obj_t data_dma_obj;
4015 struct megasas_stp_frame *kstp;
4016 struct megasas_stp_frame *stp;
4017
4018 stp = &cmd->frame->stp;
4019 kstp = (struct megasas_stp_frame *)&ioctl->frame[0];
4020
4021 model = ddi_model_convert_from(mode & FMODELS);
4022 if (model == DDI_MODEL_ILP32) {
4023 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_stp: DDI_MODEL_ILP32"));
4024
4025 fis_xferlen = kstp->sgl.sge32[0].length;
4026 data_xferlen = kstp->sgl.sge32[1].length;
4027
4028 /* SJ! - ubuf needs to be virtual address. */
4029 fis_ubuf = (void *)(ulong_t)kstp->sgl.sge32[0].phys_addr;
4030 data_ubuf = (void *)(ulong_t)kstp->sgl.sge32[1].phys_addr;
4031 }
4032 else
4033 {
4034 #ifdef _ILP32
4035 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_stp: DDI_MODEL_ILP32"));
4036
4037 fis_xferlen = kstp->sgl.sge32[0].length;
4038 data_xferlen = kstp->sgl.sge32[1].length;
4039
4040 /* SJ! - ubuf needs to be virtual address. */
4041 fis_ubuf = (void *)(ulong_t)kstp->sgl.sge32[0].phys_addr;
4042 data_ubuf = (void *)(ulong_t)kstp->sgl.sge32[1].phys_addr;
4043 #else
4044 con_log(CL_ANN1, (CE_NOTE, "issue_mfi_stp: DDI_MODEL_LP64"));
4045
4046 fis_xferlen = kstp->sgl.sge64[0].length;
4047 data_xferlen = kstp->sgl.sge64[1].length;
4048
4049 /* SJ! - ubuf needs to be virtual address. */
4050 fis_ubuf = (void *)(ulong_t)kstp->sgl.sge64[0].phys_addr;
4051 data_ubuf = (void *)(ulong_t)kstp->sgl.sge64[1].phys_addr;
4052 #endif
4053 }
4054
4055
4056 if (fis_xferlen) {
4057 con_log(CL_ANN, (CE_NOTE, "issue_mfi_stp: "
4058 "fis_ubuf = %p fis_xferlen = %x", fis_ubuf, fis_xferlen));
4059
4060 /* means IOCTL requires DMA */
4061 /* allocate the data transfer buffer */
4062 fis_dma_obj.size = fis_xferlen;
4063 fis_dma_obj.dma_attr = megasas_generic_dma_attr;
4064 fis_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
4065 fis_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
4066 fis_dma_obj.dma_attr.dma_attr_sgllen = 1;
4067 fis_dma_obj.dma_attr.dma_attr_align = 1;
4068
4069 /* allocate kernel buffer for DMA */
4070 if (mega_alloc_dma_obj(instance, &fis_dma_obj) != 1) {
4071 con_log(CL_ANN, (CE_WARN, "issue_mfi_stp: "
4072 "could not data transfer buffer alloc."));
4073 return (DDI_FAILURE);
4074 }
4075
4076 /* If IOCTL requires DMA WRITE, do ddi_copyin IOCTL data copy */
4077 if (ddi_copyin(fis_ubuf, (void *)fis_dma_obj.buffer,
4078 fis_xferlen, mode)) {
4079 con_log(CL_ANN, (CE_WARN, "issue_mfi_stp: "
4080 "copy from user space failed\n"));
4081 return (1);
4082 }
4083 }
4084
4085 if (data_xferlen) {
4086 con_log(CL_ANN, (CE_NOTE, "issue_mfi_stp: data_ubuf = %p "
4087 "data_xferlen = %x", data_ubuf, data_xferlen));
4088
4089 /* means IOCTL requires DMA */
4090 /* allocate the data transfer buffer */
4091 data_dma_obj.size = data_xferlen;
4092 data_dma_obj.dma_attr = megasas_generic_dma_attr;
4093 data_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
4094 data_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
4095 data_dma_obj.dma_attr.dma_attr_sgllen = 1;
4096 data_dma_obj.dma_attr.dma_attr_align = 1;
4097
4098 /* allocate kernel buffer for DMA */
4099 if (mega_alloc_dma_obj(instance, &data_dma_obj) != 1) {
4100 con_log(CL_ANN, (CE_WARN, "issue_mfi_stp: "
4101 "could not data transfer buffer alloc."));
4102 return (DDI_FAILURE);
4103 }
4104
4105 /* If IOCTL requires DMA WRITE, do ddi_copyin IOCTL data copy */
4106 if (ddi_copyin(data_ubuf, (void *) data_dma_obj.buffer,
4107 data_xferlen, mode)) {
4108 con_log(CL_ANN, (CE_WARN, "issue_mfi_stp: "
4109 "copy from user space failed\n"));
4110 return (1);
4111 }
4112 }
4113
4114 stp->cmd = kstp->cmd;
4115 stp->cmd_status = kstp->cmd_status;
4116 stp->connection_status = kstp->connection_status;
4117 stp->target_id = kstp->target_id;
4118 stp->sge_count = kstp->sge_count;
4119 /* stp->context = kstp->context; */
4120 stp->timeout = kstp->timeout;
4121 stp->data_xfer_len = kstp->data_xfer_len;
4122
4123 bcopy((void *)kstp->fis, (void *)stp->fis, 10);
4124
4125 stp->flags = kstp->flags & ~MFI_FRAME_SGL64;
4126 stp->stp_flags = kstp->stp_flags;
4127 stp->sgl.sge32[0].length = fis_xferlen;
4128 stp->sgl.sge32[0].phys_addr = fis_dma_obj.dma_cookie[0].dmac_address;
4129 stp->sgl.sge32[1].length = data_xferlen;
4130 stp->sgl.sge32[1].phys_addr = data_dma_obj.dma_cookie[0].dmac_address;
4131
4132 cmd->sync_cmd = MEGASAS_TRUE;
4133 cmd->frame_count = 1;
4134
4135 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
4136 con_log(CL_ANN, (CE_WARN, "issue_mfi_stp: fw_ioctl failed\n"));
4137 } else {
4138
4139 if (fis_xferlen) {
4140 if (ddi_copyout(fis_dma_obj.buffer, fis_ubuf,
4141 fis_xferlen, mode)) {
4142 con_log(CL_ANN, (CE_WARN, "issue_mfi_stp: "
4143 "copy to user space failed\n"));
4144 return (1);
4145 }
4146 }
4147
4148 if (data_xferlen) {
4149 if (ddi_copyout(data_dma_obj.buffer, data_ubuf,
4150 data_xferlen, mode)) {
4151 con_log(CL_ANN, (CE_WARN, "issue_mfi_stp: "
4152 "copy to user space failed\n"));
4153 return (1);
4154 }
4155 }
4156 }
4157
4158 kstp->cmd_status = stp->cmd_status;
4159
4160 if (fis_xferlen) {
4161 /* free kernel buffer */
4162 if (mega_free_dma_obj(instance, fis_dma_obj) != DDI_SUCCESS)
4163 return (1);
4164 }
4165
4166 if (data_xferlen) {
4167 /* free kernel buffer */
4168 if (mega_free_dma_obj(instance, data_dma_obj) != DDI_SUCCESS)
4169 return (1);
4170 }
4171
4172 return (0);
4173 }
4174
4175 /*
4176 * fill_up_drv_ver
4177 */
4178 static void
4179 fill_up_drv_ver(struct megasas_drv_ver *dv)
4180 {
4181 (void) memset(dv, 0, sizeof (struct megasas_drv_ver));
4182
4183 (void) memcpy(dv->signature, "$LSI LOGIC$", strlen("$LSI LOGIC$"));
4184 (void) memcpy(dv->os_name, "Solaris", strlen("Solaris"));
4185 (void) memcpy(dv->drv_name, "megaraid_sas", strlen("megaraid_sas"));
4186 (void) memcpy(dv->drv_ver, MEGASAS_VERSION, strlen(MEGASAS_VERSION));
4187 (void) memcpy(dv->drv_rel_date, MEGASAS_RELDATE,
4188 strlen(MEGASAS_RELDATE));
4189 }
4190
4191 /*
4192 * handle_drv_ioctl
4193 */
4194 static int
4195 handle_drv_ioctl(struct megasas_instance *instance, struct megasas_ioctl *ioctl,
4196 int mode)
4197 {
4198 int i;
4199 int rval = 0;
4200 int *props = NULL;
4201 void *ubuf;
4202
4203 uint8_t *pci_conf_buf;
4204 uint32_t xferlen;
4205 uint32_t num_props;
4206 uint_t model;
4207 struct megasas_dcmd_frame *kdcmd;
4208 struct megasas_drv_ver dv;
4209 struct megasas_pci_information pi;
4210
4211 kdcmd = (struct megasas_dcmd_frame *)&ioctl->frame[0];
4212
4213 model = ddi_model_convert_from(mode & FMODELS);
4214 if (model == DDI_MODEL_ILP32) {
4215 con_log(CL_ANN1, (CE_NOTE,
4216 "handle_drv_ioctl: DDI_MODEL_ILP32"));
4217
4218 xferlen = kdcmd->sgl.sge32[0].length;
4219
4220 /* SJ! - ubuf needs to be virtual address. */
4221 ubuf = (void *)(ulong_t)kdcmd->sgl.sge32[0].phys_addr;
4222 } else {
4223 #ifdef _ILP32
4224 con_log(CL_ANN1, (CE_NOTE,
4225 "handle_drv_ioctl: DDI_MODEL_ILP32"));
4226 xferlen = kdcmd->sgl.sge32[0].length;
4227 /* SJ! - ubuf needs to be virtual address. */
4228 ubuf = (void *)(ulong_t)kdcmd->sgl.sge32[0].phys_addr;
4229 #else
4230 con_log(CL_ANN1, (CE_NOTE,
4231 "handle_drv_ioctl: DDI_MODEL_LP64"));
4232 xferlen = kdcmd->sgl.sge64[0].length;
4233 /* SJ! - ubuf needs to be virtual address. */
4234 ubuf = (void *)(ulong_t)kdcmd->sgl.sge64[0].phys_addr;
4235 #endif
4236 }
4237 con_log(CL_ANN1, (CE_NOTE, "handle_drv_ioctl: "
4238 "dataBuf=%p size=%d bytes", ubuf, xferlen));
4239
4240 switch (kdcmd->opcode) {
4241 case MR_DRIVER_IOCTL_DRIVER_VERSION:
4242 con_log(CL_ANN1, (CE_NOTE, "handle_drv_ioctl: "
4243 "MR_DRIVER_IOCTL_DRIVER_VERSION"));
4244
4245 fill_up_drv_ver(&dv);
4246
4247 if (ddi_copyout(&dv, ubuf, xferlen, mode)) {
4248 con_log(CL_ANN, (CE_WARN, "handle_drv_ioctl: "
4249 "MR_DRIVER_IOCTL_DRIVER_VERSION : "
4250 "copy to user space failed\n"));
4251 kdcmd->cmd_status = 1;
4252 rval = 1;
4253 } else {
4254 kdcmd->cmd_status = 0;
4255 }
4256 break;
4257 case MR_DRIVER_IOCTL_PCI_INFORMATION:
4258 con_log(CL_ANN1, (CE_NOTE, "handle_drv_ioctl: "
4259 "MR_DRIVER_IOCTL_PCI_INFORMAITON"));
4260
4261 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, instance->dip,
4262 0, "reg", &props, &num_props)) {
4263 con_log(CL_ANN, (CE_WARN, "handle_drv_ioctl: "
4264 "MR_DRIVER_IOCTL_PCI_INFORMATION : "
4265 "ddi_prop_look_int_array failed\n"));
4266 rval = 1;
4267 } else {
4268
4269 pi.busNumber = (props[0] >> 16) & 0xFF;
4270 pi.deviceNumber = (props[0] >> 11) & 0x1f;
4271 pi.functionNumber = (props[0] >> 8) & 0x7;
4272 ddi_prop_free((void *)props);
4273 }
4274
4275 pci_conf_buf = (uint8_t *)&pi.pciHeaderInfo;
4276
4277 for (i = 0; i < (sizeof (struct megasas_pci_information) -
4278 offsetof(struct megasas_pci_information, pciHeaderInfo));
4279 i++) {
4280 pci_conf_buf[i] =
4281 pci_config_get8(instance->pci_handle, i);
4282 }
4283
4284 if (ddi_copyout(&pi, ubuf, xferlen, mode)) {
4285 con_log(CL_ANN, (CE_WARN, "handle_drv_ioctl: "
4286 "MR_DRIVER_IOCTL_PCI_INFORMATION : "
4287 "copy to user space failed\n"));
4288 kdcmd->cmd_status = 1;
4289 rval = 1;
4290 } else {
4291 kdcmd->cmd_status = 0;
4292 }
4293 break;
4294 default:
4295 con_log(CL_ANN, (CE_WARN, "handle_drv_ioctl: "
4296 "invalid driver specific IOCTL opcode = 0x%x",
4297 kdcmd->opcode));
4298 kdcmd->cmd_status = 1;
4299 rval = 1;
4300 break;
4301 }
4302
4303 return (rval);
4304 }
4305
4306 /*
4307 * handle_mfi_ioctl
4308 */
4309 static int
4310 handle_mfi_ioctl(struct megasas_instance *instance, struct megasas_ioctl *ioctl,
4311 int mode)
4312 {
4313 int rval = 0;
4314
4315 struct megasas_header *hdr;
4316 struct megasas_cmd *cmd;
4317
4318 cmd = get_mfi_pkt(instance);
4319
4320 if (!cmd) {
4321 con_log(CL_ANN, (CE_WARN, "megasas: "
4322 "failed to get a cmd packet\n"));
4323 return (1);
4324 }
4325
4326 hdr = (struct megasas_header *)&ioctl->frame[0];
4327
4328 switch (hdr->cmd) {
4329 case MFI_CMD_OP_DCMD:
4330 rval = issue_mfi_dcmd(instance, ioctl, cmd, mode);
4331 break;
4332 case MFI_CMD_OP_SMP:
4333 rval = issue_mfi_smp(instance, ioctl, cmd, mode);
4334 break;
4335 case MFI_CMD_OP_STP:
4336 rval = issue_mfi_stp(instance, ioctl, cmd, mode);
4337 break;
4338 case MFI_CMD_OP_LD_SCSI:
4339 case MFI_CMD_OP_PD_SCSI:
4340 rval = issue_mfi_pthru(instance, ioctl, cmd, mode);
4341 break;
4342 default:
4343 con_log(CL_ANN, (CE_WARN, "handle_mfi_ioctl: "
4344 "invalid mfi ioctl hdr->cmd = %d\n", hdr->cmd));
4345 rval = 1;
4346 break;
4347 }
4348
4349
4350 return_mfi_pkt(instance, cmd);
4351 if (megasas_common_check(instance, cmd) != DDI_SUCCESS)
4352 rval = 1;
4353 return (rval);
4354 }
4355
4356 /*
4357 * AEN
4358 */
4359 static int
4360 handle_mfi_aen(struct megasas_instance *instance, struct megasas_aen *aen)
4361 {
4362 int rval = 0;
4363
4364 rval = register_mfi_aen(instance, instance->aen_seq_num,
4365 aen->class_locale_word);
4366
4367 aen->cmd_status = (uint8_t)rval;
4368
4369 return (rval);
4370 }
4371
4372 static int
4373 register_mfi_aen(struct megasas_instance *instance, uint32_t seq_num,
4374 uint32_t class_locale_word)
4375 {
4376 int ret_val;
4377
4378 struct megasas_cmd *cmd;
4379 struct megasas_dcmd_frame *dcmd;
4380 union megasas_evt_class_locale curr_aen;
4381 union megasas_evt_class_locale prev_aen;
4382
4383 /*
4384 * If there an AEN pending already (aen_cmd), check if the
4385 * class_locale of that pending AEN is inclusive of the new
4386 * AEN request we currently have. If it is, then we don't have
4387 * to do anything. In other words, whichever events the current
4388 * AEN request is subscribing to, have already been subscribed
4389 * to.
4390 *
4391 * If the old_cmd is _not_ inclusive, then we have to abort
4392 * that command, form a class_locale that is superset of both
4393 * old and current and re-issue to the FW
4394 */
4395
4396 curr_aen.word = class_locale_word;
4397
4398 if (instance->aen_cmd) {
4399 prev_aen.word = instance->aen_cmd->frame->dcmd.mbox.w[1];
4400
4401 /*
4402 * A class whose enum value is smaller is inclusive of all
4403 * higher values. If a PROGRESS (= -1) was previously
4404 * registered, then a new registration requests for higher
4405 * classes need not be sent to FW. They are automatically
4406 * included.
4407 *
4408 * Locale numbers don't have such hierarchy. They are bitmap
4409 * values
4410 */
4411 if ((prev_aen.members.class <= curr_aen.members.class) &&
4412 !((prev_aen.members.locale & curr_aen.members.locale) ^
4413 curr_aen.members.locale)) {
4414 /*
4415 * Previously issued event registration includes
4416 * current request. Nothing to do.
4417 */
4418
4419 return (0);
4420 } else {
4421 curr_aen.members.locale |= prev_aen.members.locale;
4422
4423 if (prev_aen.members.class < curr_aen.members.class)
4424 curr_aen.members.class = prev_aen.members.class;
4425
4426 ret_val = abort_aen_cmd(instance, instance->aen_cmd);
4427
4428 if (ret_val) {
4429 con_log(CL_ANN, (CE_WARN, "register_mfi_aen: "
4430 "failed to abort prevous AEN command\n"));
4431
4432 return (ret_val);
4433 }
4434 }
4435 } else {
4436 curr_aen.word = class_locale_word;
4437 }
4438
4439 cmd = get_mfi_pkt(instance);
4440
4441 if (!cmd)
4442 return (-ENOMEM);
4443
4444 dcmd = &cmd->frame->dcmd;
4445
4446 /* for(i = 0; i < DCMD_MBOX_SZ; i++) dcmd->mbox.b[i] = 0; */
4447 (void) memset(dcmd->mbox.b, 0, DCMD_MBOX_SZ);
4448
4449 (void) memset(instance->mfi_evt_detail_obj.buffer, 0,
4450 sizeof (struct megasas_evt_detail));
4451
4452 /* Prepare DCMD for aen registration */
4453 dcmd->cmd = MFI_CMD_OP_DCMD;
4454 dcmd->cmd_status = 0x0;
4455 dcmd->sge_count = 1;
4456 dcmd->flags = MFI_FRAME_DIR_READ;
4457 dcmd->timeout = 0;
4458 dcmd->data_xfer_len = sizeof (struct megasas_evt_detail);
4459 dcmd->opcode = MR_DCMD_CTRL_EVENT_WAIT;
4460 dcmd->mbox.w[0] = seq_num;
4461 dcmd->mbox.w[1] = curr_aen.word;
4462 dcmd->sgl.sge32[0].phys_addr =
4463 instance->mfi_evt_detail_obj.dma_cookie[0].dmac_address;
4464 dcmd->sgl.sge32[0].length = sizeof (struct megasas_evt_detail);
4465
4466 instance->aen_seq_num = seq_num;
4467
4468 /*
4469 * Store reference to the cmd used to register for AEN. When an
4470 * application wants us to register for AEN, we have to abort this
4471 * cmd and re-register with a new EVENT LOCALE supplied by that app
4472 */
4473 instance->aen_cmd = cmd;
4474
4475 cmd->frame_count = 1;
4476
4477 /* Issue the aen registration frame */
4478 /* atomic_add_16 (&instance->fw_outstanding, 1); */
4479 instance->func_ptr->issue_cmd(cmd, instance);
4480
4481 return (0);
4482 }
4483
4484 static void
4485 display_scsi_inquiry(caddr_t scsi_inq)
4486 {
4487 #define MAX_SCSI_DEVICE_CODE 14
4488 int i;
4489 char inquiry_buf[256] = {0};
4490 int len;
4491 const char *const scsi_device_types[] = {
4492 "Direct-Access ",
4493 "Sequential-Access",
4494 "Printer ",
4495 "Processor ",
4496 "WORM ",
4497 "CD-ROM ",
4498 "Scanner ",
4499 "Optical Device ",
4500 "Medium Changer ",
4501 "Communications ",
4502 "Unknown ",
4503 "Unknown ",
4504 "Unknown ",
4505 "Enclosure ",
4506 };
4507
4508 len = 0;
4509
4510 len += snprintf(inquiry_buf + len, 265 - len, " Vendor: ");
4511 for (i = 8; i < 16; i++) {
4512 len += snprintf(inquiry_buf + len, 265 - len, "%c",
4513 scsi_inq[i]);
4514 }
4515
4516 len += snprintf(inquiry_buf + len, 265 - len, " Model: ");
4517
4518 for (i = 16; i < 32; i++) {
4519 len += snprintf(inquiry_buf + len, 265 - len, "%c",
4520 scsi_inq[i]);
4521 }
4522
4523 len += snprintf(inquiry_buf + len, 265 - len, " Rev: ");
4524
4525 for (i = 32; i < 36; i++) {
4526 len += snprintf(inquiry_buf + len, 265 - len, "%c",
4527 scsi_inq[i]);
4528 }
4529
4530 len += snprintf(inquiry_buf + len, 265 - len, "\n");
4531
4532
4533 i = scsi_inq[0] & 0x1f;
4534
4535
4536 len += snprintf(inquiry_buf + len, 265 - len, " Type: %s ",
4537 i < MAX_SCSI_DEVICE_CODE ? scsi_device_types[i] :
4538 "Unknown ");
4539
4540
4541 len += snprintf(inquiry_buf + len, 265 - len,
4542 " ANSI SCSI revision: %02x", scsi_inq[2] & 0x07);
4543
4544 if ((scsi_inq[2] & 0x07) == 1 && (scsi_inq[3] & 0x0f) == 1) {
4545 len += snprintf(inquiry_buf + len, 265 - len, " CCS\n");
4546 } else {
4547 len += snprintf(inquiry_buf + len, 265 - len, "\n");
4548 }
4549
4550 con_log(CL_ANN1, (CE_CONT, inquiry_buf));
4551 }
4552
4553 static int
4554 read_fw_status_reg_xscale(struct megasas_instance *instance)
4555 {
4556 return ((int)RD_OB_MSG_0(instance));
4557 }
4558
4559 static int
4560 read_fw_status_reg_ppc(struct megasas_instance *instance)
4561 {
4562 return ((int)RD_OB_SCRATCH_PAD_0(instance));
4563 }
4564
4565 static void
4566 issue_cmd_xscale(struct megasas_cmd *cmd, struct megasas_instance *instance)
4567 {
4568 atomic_inc_16(&instance->fw_outstanding);
4569
4570 /* Issue the command to the FW */
4571 WR_IB_QPORT((host_to_le32(cmd->frame_phys_addr) >> 3) |
4572 (cmd->frame_count - 1), instance);
4573 }
4574
4575 static void
4576 issue_cmd_ppc(struct megasas_cmd *cmd, struct megasas_instance *instance)
4577 {
4578 atomic_inc_16(&instance->fw_outstanding);
4579
4580 /* Issue the command to the FW */
4581 WR_IB_QPORT((host_to_le32(cmd->frame_phys_addr)) |
4582 (((cmd->frame_count - 1) << 1) | 1), instance);
4583 }
4584
4585 /*
4586 * issue_cmd_in_sync_mode
4587 */
4588 static int
4589 issue_cmd_in_sync_mode_xscale(struct megasas_instance *instance,
4590 struct megasas_cmd *cmd)
4591 {
4592 int i;
4593 uint32_t msecs = MFI_POLL_TIMEOUT_SECS * (10 * MILLISEC);
4594
4595 cmd->cmd_status = ENODATA;
4596
4597 WR_IB_QPORT((host_to_le32(cmd->frame_phys_addr) >> 3) |
4598 (cmd->frame_count - 1), instance);
4599
4600 mutex_enter(&instance->int_cmd_mtx);
4601
4602 for (i = 0; i < msecs && (cmd->cmd_status == ENODATA); i++) {
4603 cv_wait(&instance->int_cmd_cv, &instance->int_cmd_mtx);
4604 }
4605
4606 mutex_exit(&instance->int_cmd_mtx);
4607
4608 if (i < (msecs -1)) {
4609 return (0);
4610 } else {
4611 return (1);
4612 }
4613 }
4614
4615 static int
4616 issue_cmd_in_sync_mode_ppc(struct megasas_instance *instance,
4617 struct megasas_cmd *cmd)
4618 {
4619 int i;
4620 uint32_t msecs = MFI_POLL_TIMEOUT_SECS * (10 * MILLISEC);
4621
4622 con_log(CL_ANN1, (CE_NOTE, "issue_cmd_in_sync_mode_ppc: called\n"));
4623
4624 cmd->cmd_status = ENODATA;
4625
4626 WR_IB_QPORT((host_to_le32(cmd->frame_phys_addr)) |
4627 (((cmd->frame_count - 1) << 1) | 1), instance);
4628
4629 mutex_enter(&instance->int_cmd_mtx);
4630
4631 for (i = 0; i < msecs && (cmd->cmd_status == ENODATA); i++) {
4632 cv_wait(&instance->int_cmd_cv, &instance->int_cmd_mtx);
4633 }
4634
4635 mutex_exit(&instance->int_cmd_mtx);
4636
4637 con_log(CL_ANN1, (CE_NOTE, "issue_cmd_in_sync_mode_ppc: done\n"));
4638
4639 if (i < (msecs -1)) {
4640 return (0);
4641 } else {
4642 return (1);
4643 }
4644 }
4645
4646 /*
4647 * issue_cmd_in_poll_mode
4648 */
4649 static int
4650 issue_cmd_in_poll_mode_xscale(struct megasas_instance *instance,
4651 struct megasas_cmd *cmd)
4652 {
4653 int i;
4654 uint32_t msecs = MFI_POLL_TIMEOUT_SECS * MILLISEC;
4655 struct megasas_header *frame_hdr;
4656
4657 frame_hdr = (struct megasas_header *)cmd->frame;
4658 frame_hdr->cmd_status = MFI_CMD_STATUS_POLL_MODE;
4659 frame_hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
4660
4661 /* issue the frame using inbound queue port */
4662 WR_IB_QPORT((host_to_le32(cmd->frame_phys_addr) >> 3) |
4663 (cmd->frame_count - 1), instance);
4664
4665 /* wait for cmd_status to change from 0xFF */
4666 for (i = 0; i < msecs && (frame_hdr->cmd_status ==
4667 MFI_CMD_STATUS_POLL_MODE); i++) {
4668 drv_usecwait(MILLISEC); /* wait for 1000 usecs */
4669 }
4670
4671 if (frame_hdr->cmd_status == MFI_CMD_STATUS_POLL_MODE) {
4672 con_log(CL_ANN, (CE_NOTE, "issue_cmd_in_poll_mode: "
4673 "cmd polling timed out"));
4674 return (DDI_FAILURE);
4675 }
4676
4677 return (DDI_SUCCESS);
4678 }
4679
4680 static int
4681 issue_cmd_in_poll_mode_ppc(struct megasas_instance *instance,
4682 struct megasas_cmd *cmd)
4683 {
4684 int i;
4685 uint32_t msecs = MFI_POLL_TIMEOUT_SECS * MILLISEC;
4686 struct megasas_header *frame_hdr;
4687
4688 con_log(CL_ANN1, (CE_NOTE, "issue_cmd_in_poll_mode_ppc: called\n"));
4689
4690 frame_hdr = (struct megasas_header *)cmd->frame;
4691 frame_hdr->cmd_status = MFI_CMD_STATUS_POLL_MODE;
4692 frame_hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
4693
4694 /* issue the frame using inbound queue port */
4695 WR_IB_QPORT((host_to_le32(cmd->frame_phys_addr)) |
4696 (((cmd->frame_count - 1) << 1) | 1), instance);
4697
4698 /* wait for cmd_status to change from 0xFF */
4699 for (i = 0; i < msecs && (frame_hdr->cmd_status ==
4700 MFI_CMD_STATUS_POLL_MODE); i++) {
4701 drv_usecwait(MILLISEC); /* wait for 1000 usecs */
4702 }
4703
4704 if (frame_hdr->cmd_status == MFI_CMD_STATUS_POLL_MODE) {
4705 con_log(CL_ANN, (CE_NOTE, "issue_cmd_in_poll_mode: "
4706 "cmd polling timed out"));
4707 return (DDI_FAILURE);
4708 }
4709
4710 return (DDI_SUCCESS);
4711 }
4712
4713 static void
4714 enable_intr_xscale(struct megasas_instance *instance)
4715 {
4716 MFI_ENABLE_INTR(instance);
4717 }
4718
4719 static void
4720 enable_intr_ppc(struct megasas_instance *instance)
4721 {
4722 uint32_t mask;
4723
4724 con_log(CL_ANN1, (CE_NOTE, "enable_intr_ppc: called\n"));
4725
4726 /* WR_OB_DOORBELL_CLEAR(0xFFFFFFFF, instance); */
4727 WR_OB_DOORBELL_CLEAR(OB_DOORBELL_CLEAR_MASK, instance);
4728
4729 /*
4730 * As 1078DE is same as 1078 chip, the interrupt mask
4731 * remains the same.
4732 */
4733 /* WR_OB_INTR_MASK(~0x80000000, instance); */
4734 WR_OB_INTR_MASK(~(MFI_REPLY_1078_MESSAGE_INTR), instance);
4735
4736 /* dummy read to force PCI flush */
4737 mask = RD_OB_INTR_MASK(instance);
4738
4739 con_log(CL_ANN1, (CE_NOTE, "enable_intr_ppc: "
4740 "outbound_intr_mask = 0x%x\n", mask));
4741 }
4742
4743 static void
4744 disable_intr_xscale(struct megasas_instance *instance)
4745 {
4746 MFI_DISABLE_INTR(instance);
4747 }
4748
4749 static void
4750 disable_intr_ppc(struct megasas_instance *instance)
4751 {
4752 uint32_t mask;
4753
4754 con_log(CL_ANN1, (CE_NOTE, "disable_intr_ppc: called\n"));
4755
4756 con_log(CL_ANN1, (CE_NOTE, "disable_intr_ppc: before : "
4757 "outbound_intr_mask = 0x%x\n", RD_OB_INTR_MASK(instance)));
4758
4759 /* WR_OB_INTR_MASK(0xFFFFFFFF, instance); */
4760 WR_OB_INTR_MASK(OB_INTR_MASK, instance);
4761
4762 con_log(CL_ANN1, (CE_NOTE, "disable_intr_ppc: after : "
4763 "outbound_intr_mask = 0x%x\n", RD_OB_INTR_MASK(instance)));
4764
4765 /* dummy read to force PCI flush */
4766 mask = RD_OB_INTR_MASK(instance);
4767 #ifdef lint
4768 mask = mask;
4769 #endif
4770 }
4771
4772 static int
4773 intr_ack_xscale(struct megasas_instance *instance)
4774 {
4775 uint32_t status;
4776
4777 /* check if it is our interrupt */
4778 status = RD_OB_INTR_STATUS(instance);
4779
4780 if (!(status & MFI_OB_INTR_STATUS_MASK)) {
4781 return (DDI_INTR_UNCLAIMED);
4782 }
4783
4784 /* clear the interrupt by writing back the same value */
4785 WR_OB_INTR_STATUS(status, instance);
4786
4787 return (DDI_INTR_CLAIMED);
4788 }
4789
4790 static int
4791 intr_ack_ppc(struct megasas_instance *instance)
4792 {
4793 uint32_t status;
4794
4795 con_log(CL_ANN1, (CE_NOTE, "intr_ack_ppc: called\n"));
4796
4797 /* check if it is our interrupt */
4798 status = RD_OB_INTR_STATUS(instance);
4799
4800 con_log(CL_ANN1, (CE_NOTE, "intr_ack_ppc: status = 0x%x\n", status));
4801
4802 /*
4803 * As 1078DE is same as 1078 chip, the status field
4804 * remains the same.
4805 */
4806 if (!(status & MFI_REPLY_1078_MESSAGE_INTR)) {
4807 return (DDI_INTR_UNCLAIMED);
4808 }
4809
4810 /* clear the interrupt by writing back the same value */
4811 WR_OB_DOORBELL_CLEAR(status, instance);
4812
4813 /* dummy READ */
4814 status = RD_OB_INTR_STATUS(instance);
4815
4816 con_log(CL_ANN1, (CE_NOTE, "intr_ack_ppc: interrupt cleared\n"));
4817
4818 return (DDI_INTR_CLAIMED);
4819 }
4820
4821 static int
4822 megasas_common_check(struct megasas_instance *instance,
4823 struct megasas_cmd *cmd)
4824 {
4825 int ret = DDI_SUCCESS;
4826
4827 if (megasas_check_dma_handle(cmd->frame_dma_obj.dma_handle) !=
4828 DDI_SUCCESS) {
4829 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
4830 if (cmd->pkt != NULL) {
4831 cmd->pkt->pkt_reason = CMD_TRAN_ERR;
4832 cmd->pkt->pkt_statistics = 0;
4833 }
4834 ret = DDI_FAILURE;
4835 }
4836 if (megasas_check_dma_handle(instance->mfi_internal_dma_obj.dma_handle)
4837 != DDI_SUCCESS) {
4838 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
4839 if (cmd->pkt != NULL) {
4840 cmd->pkt->pkt_reason = CMD_TRAN_ERR;
4841 cmd->pkt->pkt_statistics = 0;
4842 }
4843 ret = DDI_FAILURE;
4844 }
4845 if (megasas_check_dma_handle(instance->mfi_evt_detail_obj.dma_handle) !=
4846 DDI_SUCCESS) {
4847 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
4848 if (cmd->pkt != NULL) {
4849 cmd->pkt->pkt_reason = CMD_TRAN_ERR;
4850 cmd->pkt->pkt_statistics = 0;
4851 }
4852 ret = DDI_FAILURE;
4853 }
4854 if (megasas_check_acc_handle(instance->regmap_handle) != DDI_SUCCESS) {
4855 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
4856 ddi_fm_acc_err_clear(instance->regmap_handle, DDI_FME_VER0);
4857 if (cmd->pkt != NULL) {
4858 cmd->pkt->pkt_reason = CMD_TRAN_ERR;
4859 cmd->pkt->pkt_statistics = 0;
4860 }
4861 ret = DDI_FAILURE;
4862 }
4863
4864 return (ret);
4865 }
4866
4867 /*ARGSUSED*/
4868 static int
4869 megasas_fm_error_cb(dev_info_t *dip, ddi_fm_error_t *err, const void *impl_data)
4870 {
4871 /*
4872 * as the driver can always deal with an error in any dma or
4873 * access handle, we can just return the fme_status value.
4874 */
4875 pci_ereport_post(dip, err, NULL);
4876 return (err->fme_status);
4877 }
4878
4879 static void
4880 megasas_fm_init(struct megasas_instance *instance)
4881 {
4882 /* Need to change iblock to priority for new MSI intr */
4883 ddi_iblock_cookie_t fm_ibc;
4884
4885 /* Only register with IO Fault Services if we have some capability */
4886 if (instance->fm_capabilities) {
4887 /* Adjust access and dma attributes for FMA */
4888 endian_attr.devacc_attr_access = DDI_FLAGERR_ACC;
4889 megasas_generic_dma_attr.dma_attr_flags = DDI_DMA_FLAGERR;
4890
4891 /*
4892 * Register capabilities with IO Fault Services.
4893 * fm_capabilities will be updated to indicate
4894 * capabilities actually supported (not requested.)
4895 */
4896
4897 ddi_fm_init(instance->dip, &instance->fm_capabilities, &fm_ibc);
4898
4899 /*
4900 * Initialize pci ereport capabilities if ereport
4901 * capable (should always be.)
4902 */
4903
4904 if (DDI_FM_EREPORT_CAP(instance->fm_capabilities) ||
4905 DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
4906 pci_ereport_setup(instance->dip);
4907 }
4908
4909 /*
4910 * Register error callback if error callback capable.
4911 */
4912 if (DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
4913 ddi_fm_handler_register(instance->dip,
4914 megasas_fm_error_cb, (void*) instance);
4915 }
4916 } else {
4917 endian_attr.devacc_attr_access = DDI_DEFAULT_ACC;
4918 megasas_generic_dma_attr.dma_attr_flags = 0;
4919 }
4920 }
4921
4922 static void
4923 megasas_fm_fini(struct megasas_instance *instance)
4924 {
4925 /* Only unregister FMA capabilities if registered */
4926 if (instance->fm_capabilities) {
4927 /*
4928 * Un-register error callback if error callback capable.
4929 */
4930 if (DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
4931 ddi_fm_handler_unregister(instance->dip);
4932 }
4933
4934 /*
4935 * Release any resources allocated by pci_ereport_setup()
4936 */
4937 if (DDI_FM_EREPORT_CAP(instance->fm_capabilities) ||
4938 DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
4939 pci_ereport_teardown(instance->dip);
4940 }
4941
4942 /* Unregister from IO Fault Services */
4943 ddi_fm_fini(instance->dip);
4944
4945 /* Adjust access and dma attributes for FMA */
4946 endian_attr.devacc_attr_access = DDI_DEFAULT_ACC;
4947 megasas_generic_dma_attr.dma_attr_flags = 0;
4948 }
4949 }
4950
4951 int
4952 megasas_check_acc_handle(ddi_acc_handle_t handle)
4953 {
4954 ddi_fm_error_t de;
4955
4956 if (handle == NULL) {
4957 return (DDI_FAILURE);
4958 }
4959
4960 ddi_fm_acc_err_get(handle, &de, DDI_FME_VERSION);
4961
4962 return (de.fme_status);
4963 }
4964
4965 int
4966 megasas_check_dma_handle(ddi_dma_handle_t handle)
4967 {
4968 ddi_fm_error_t de;
4969
4970 if (handle == NULL) {
4971 return (DDI_FAILURE);
4972 }
4973
4974 ddi_fm_dma_err_get(handle, &de, DDI_FME_VERSION);
4975
4976 return (de.fme_status);
4977 }
4978
4979 void
4980 megasas_fm_ereport(struct megasas_instance *instance, char *detail)
4981 {
4982 uint64_t ena;
4983 char buf[FM_MAX_CLASS];
4984
4985 (void) snprintf(buf, FM_MAX_CLASS, "%s.%s", DDI_FM_DEVICE, detail);
4986 ena = fm_ena_generate(0, FM_ENA_FMT1);
4987 if (DDI_FM_EREPORT_CAP(instance->fm_capabilities)) {
4988 ddi_fm_ereport_post(instance->dip, buf, ena, DDI_NOSLEEP,
4989 FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERSION, NULL);
4990 }
4991 }