xref: /illumos-gate/usr/src/uts/common/io/mr_sas/mr_sas.c (revision 97ac1f64)
1 /*
2  * mr_sas.c: source for mr_sas driver
3  *
4  * Solaris MegaRAID device driver for SAS2.0 controllers
5  * Copyright (c) 2008-2012, LSI Logic Corporation.
6  * All rights reserved.
7  *
8  * Version:
9  * Author:
10  *		Swaminathan K S
11  *		Arun Chandrashekhar
12  *		Manju R
13  *		Rasheed
14  *		Shakeel Bukhari
15  *
16  * Redistribution and use in source and binary forms, with or without
17  * modification, are permitted provided that the following conditions are met:
18  *
19  * 1. Redistributions of source code must retain the above copyright notice,
20  *    this list of conditions and the following disclaimer.
21  *
22  * 2. Redistributions in binary form must reproduce the above copyright notice,
23  *    this list of conditions and the following disclaimer in the documentation
24  *    and/or other materials provided with the distribution.
25  *
26  * 3. Neither the name of the author nor the names of its contributors may be
27  *    used to endorse or promote products derived from this software without
28  *    specific prior written permission.
29  *
30  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
31  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
32  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
33  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
34  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
35  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
36  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
37  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
38  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
39  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
40  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
41  * DAMAGE.
42  */
43 
44 /*
45  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
46  * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
47  * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
48  * Copyright 2015, 2017 Citrus IT Limited. All rights reserved.
49  * Copyright 2015 Garrett D'Amore <garrett@damore.org>
50  */
51 
52 #include <sys/types.h>
53 #include <sys/param.h>
54 #include <sys/file.h>
55 #include <sys/errno.h>
56 #include <sys/open.h>
57 #include <sys/cred.h>
58 #include <sys/modctl.h>
59 #include <sys/conf.h>
60 #include <sys/devops.h>
61 #include <sys/cmn_err.h>
62 #include <sys/kmem.h>
63 #include <sys/stat.h>
64 #include <sys/mkdev.h>
65 #include <sys/pci.h>
66 #include <sys/scsi/scsi.h>
67 #include <sys/ddi.h>
68 #include <sys/sunddi.h>
69 #include <sys/atomic.h>
70 #include <sys/signal.h>
71 #include <sys/byteorder.h>
72 #include <sys/sdt.h>
73 #include <sys/fs/dv_node.h>	/* devfs_clean */
74 
75 #include "mr_sas.h"
76 
77 /*
78  * FMA header files
79  */
80 #include <sys/ddifm.h>
81 #include <sys/fm/protocol.h>
82 #include <sys/fm/util.h>
83 #include <sys/fm/io/ddi.h>
84 
85 /* Macros to help Skinny and stock 2108/MFI live together. */
86 #define	WR_IB_PICK_QPORT(addr, instance) \
87 	if ((instance)->skinny) { \
88 		WR_IB_LOW_QPORT((addr), (instance)); \
89 		WR_IB_HIGH_QPORT(0, (instance)); \
90 	} else { \
91 		WR_IB_QPORT((addr), (instance)); \
92 	}
93 
94 /*
95  * Local static data
96  */
97 static void	*mrsas_state = NULL;
98 static volatile boolean_t	mrsas_relaxed_ordering = B_TRUE;
99 volatile int	debug_level_g = CL_NONE;
100 static volatile int	msi_enable = 1;
101 static volatile int	ctio_enable = 1;
102 
103 /* Default Timeout value to issue online controller reset */
104 volatile int  debug_timeout_g  = 0xF0;		/* 0xB4; */
105 /* Simulate consecutive firmware fault */
106 static volatile int  debug_fw_faults_after_ocr_g  = 0;
107 #ifdef OCRDEBUG
108 /* Simulate three consecutive timeout for an IO */
109 static volatile int  debug_consecutive_timeout_after_ocr_g  = 0;
110 #endif
111 
112 #pragma weak scsi_hba_open
113 #pragma weak scsi_hba_close
114 #pragma weak scsi_hba_ioctl
115 
116 /* Local static prototypes. */
117 static int	mrsas_getinfo(dev_info_t *, ddi_info_cmd_t,  void *, void **);
118 static int	mrsas_attach(dev_info_t *, ddi_attach_cmd_t);
119 #ifdef __sparc
120 static int	mrsas_reset(dev_info_t *, ddi_reset_cmd_t);
121 #else
122 static int	mrsas_quiesce(dev_info_t *);
123 #endif
124 static int	mrsas_detach(dev_info_t *, ddi_detach_cmd_t);
125 static int	mrsas_open(dev_t *, int, int, cred_t *);
126 static int	mrsas_close(dev_t, int, int, cred_t *);
127 static int	mrsas_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
128 
129 static int	mrsas_tran_tgt_init(dev_info_t *, dev_info_t *,
130 		    scsi_hba_tran_t *, struct scsi_device *);
131 static struct scsi_pkt *mrsas_tran_init_pkt(struct scsi_address *, register
132 		    struct scsi_pkt *, struct buf *, int, int, int, int,
133 		    int (*)(), caddr_t);
134 static int	mrsas_tran_start(struct scsi_address *,
135 		    register struct scsi_pkt *);
136 static int	mrsas_tran_abort(struct scsi_address *, struct scsi_pkt *);
137 static int	mrsas_tran_reset(struct scsi_address *, int);
138 static int	mrsas_tran_getcap(struct scsi_address *, char *, int);
139 static int	mrsas_tran_setcap(struct scsi_address *, char *, int, int);
140 static void	mrsas_tran_destroy_pkt(struct scsi_address *,
141 		    struct scsi_pkt *);
142 static void	mrsas_tran_dmafree(struct scsi_address *, struct scsi_pkt *);
143 static void	mrsas_tran_sync_pkt(struct scsi_address *, struct scsi_pkt *);
144 static int	mrsas_tran_quiesce(dev_info_t *dip);
145 static int	mrsas_tran_unquiesce(dev_info_t *dip);
146 static uint_t	mrsas_isr(caddr_t, caddr_t);
147 static uint_t	mrsas_softintr();
148 static void	mrsas_undo_resources(dev_info_t *, struct mrsas_instance *);
149 
150 static void	free_space_for_mfi(struct mrsas_instance *);
151 static uint32_t	read_fw_status_reg_ppc(struct mrsas_instance *);
152 static void	issue_cmd_ppc(struct mrsas_cmd *, struct mrsas_instance *);
153 static int	issue_cmd_in_poll_mode_ppc(struct mrsas_instance *,
154 		    struct mrsas_cmd *);
155 static int	issue_cmd_in_sync_mode_ppc(struct mrsas_instance *,
156 		    struct mrsas_cmd *);
157 static void	enable_intr_ppc(struct mrsas_instance *);
158 static void	disable_intr_ppc(struct mrsas_instance *);
159 static int	intr_ack_ppc(struct mrsas_instance *);
160 static void	flush_cache(struct mrsas_instance *instance);
161 void	display_scsi_inquiry(caddr_t);
162 static int	start_mfi_aen(struct mrsas_instance *instance);
163 static int	handle_drv_ioctl(struct mrsas_instance *instance,
164 		    struct mrsas_ioctl *ioctl, int mode);
165 static int	handle_mfi_ioctl(struct mrsas_instance *instance,
166 		    struct mrsas_ioctl *ioctl, int mode);
167 static int	handle_mfi_aen(struct mrsas_instance *instance,
168 		    struct mrsas_aen *aen);
169 static struct mrsas_cmd *build_cmd(struct mrsas_instance *,
170     struct scsi_address *, struct scsi_pkt *, uchar_t *);
171 static int	alloc_additional_dma_buffer(struct mrsas_instance *);
172 static void	complete_cmd_in_sync_mode(struct mrsas_instance *,
173 		struct mrsas_cmd *);
174 static int	mrsas_kill_adapter(struct mrsas_instance *);
175 static int	mrsas_issue_init_mfi(struct mrsas_instance *);
176 static int	mrsas_reset_ppc(struct mrsas_instance *);
177 static uint32_t mrsas_initiate_ocr_if_fw_is_faulty(struct mrsas_instance *);
178 static int	wait_for_outstanding(struct mrsas_instance *instance);
179 static int	register_mfi_aen(struct mrsas_instance *instance,
180 		    uint32_t seq_num, uint32_t class_locale_word);
181 static int	issue_mfi_pthru(struct mrsas_instance *instance, struct
182 		    mrsas_ioctl *ioctl, struct mrsas_cmd *cmd, int mode);
183 static int	issue_mfi_dcmd(struct mrsas_instance *instance, struct
184 		    mrsas_ioctl *ioctl, struct mrsas_cmd *cmd, int mode);
185 static int	issue_mfi_smp(struct mrsas_instance *instance, struct
186 		    mrsas_ioctl *ioctl, struct mrsas_cmd *cmd, int mode);
187 static int	issue_mfi_stp(struct mrsas_instance *instance, struct
188 		    mrsas_ioctl *ioctl, struct mrsas_cmd *cmd, int mode);
189 static int	abort_aen_cmd(struct mrsas_instance *instance,
190 		    struct mrsas_cmd *cmd_to_abort);
191 
192 static void	mrsas_rem_intrs(struct mrsas_instance *instance);
193 static int	mrsas_add_intrs(struct mrsas_instance *instance, int intr_type);
194 
195 static void	mrsas_tran_tgt_free(dev_info_t *, dev_info_t *,
196 		    scsi_hba_tran_t *, struct scsi_device *);
197 static int	mrsas_tran_bus_config(dev_info_t *, uint_t,
198 		    ddi_bus_config_op_t, void *, dev_info_t **);
199 static int	mrsas_parse_devname(char *, int *, int *);
200 static int	mrsas_config_all_devices(struct mrsas_instance *);
201 static int	mrsas_config_ld(struct mrsas_instance *, uint16_t,
202 			uint8_t, dev_info_t **);
203 static int	mrsas_name_node(dev_info_t *, char *, int);
204 static void	mrsas_issue_evt_taskq(struct mrsas_eventinfo *);
205 static void	free_additional_dma_buffer(struct mrsas_instance *);
206 static void io_timeout_checker(void *);
207 static void mrsas_fm_init(struct mrsas_instance *);
208 static void mrsas_fm_fini(struct mrsas_instance *);
209 
210 static struct mrsas_function_template mrsas_function_template_ppc = {
211 	.read_fw_status_reg = read_fw_status_reg_ppc,
212 	.issue_cmd = issue_cmd_ppc,
213 	.issue_cmd_in_sync_mode = issue_cmd_in_sync_mode_ppc,
214 	.issue_cmd_in_poll_mode = issue_cmd_in_poll_mode_ppc,
215 	.enable_intr = enable_intr_ppc,
216 	.disable_intr = disable_intr_ppc,
217 	.intr_ack = intr_ack_ppc,
218 	.init_adapter = mrsas_init_adapter_ppc
219 };
220 
221 
222 static struct mrsas_function_template mrsas_function_template_fusion = {
223 	.read_fw_status_reg = tbolt_read_fw_status_reg,
224 	.issue_cmd = tbolt_issue_cmd,
225 	.issue_cmd_in_sync_mode = tbolt_issue_cmd_in_sync_mode,
226 	.issue_cmd_in_poll_mode = tbolt_issue_cmd_in_poll_mode,
227 	.enable_intr = tbolt_enable_intr,
228 	.disable_intr = tbolt_disable_intr,
229 	.intr_ack = tbolt_intr_ack,
230 	.init_adapter = mrsas_init_adapter_tbolt
231 };
232 
233 
234 ddi_dma_attr_t mrsas_generic_dma_attr = {
235 	DMA_ATTR_V0,		/* dma_attr_version */
236 	0,			/* low DMA address range */
237 	0xFFFFFFFFU,		/* high DMA address range */
238 	0xFFFFFFFFU,		/* DMA counter register	 */
239 	8,			/* DMA address alignment */
240 	0x07,			/* DMA burstsizes  */
241 	1,			/* min DMA size */
242 	0xFFFFFFFFU,		/* max DMA size */
243 	0xFFFFFFFFU,		/* segment boundary */
244 	MRSAS_MAX_SGE_CNT,	/* dma_attr_sglen */
245 	512,			/* granularity of device */
246 	0			/* bus specific DMA flags */
247 };
248 
249 int32_t mrsas_max_cap_maxxfer = 0x1000000;
250 
251 /*
252  * Fix for: Thunderbolt controller IO timeout when IO write size is 1MEG,
253  * Limit size to 256K
254  */
255 uint32_t mrsas_tbolt_max_cap_maxxfer = (512 * 512);
256 
257 /*
258  * cb_ops contains base level routines
259  */
260 static struct cb_ops mrsas_cb_ops = {
261 	mrsas_open,		/* open */
262 	mrsas_close,		/* close */
263 	nodev,			/* strategy */
264 	nodev,			/* print */
265 	nodev,			/* dump */
266 	nodev,			/* read */
267 	nodev,			/* write */
268 	mrsas_ioctl,		/* ioctl */
269 	nodev,			/* devmap */
270 	nodev,			/* mmap */
271 	nodev,			/* segmap */
272 	nochpoll,		/* poll */
273 	nodev,			/* cb_prop_op */
274 	0,			/* streamtab  */
275 	D_NEW | D_HOTPLUG,	/* cb_flag */
276 	CB_REV,			/* cb_rev */
277 	nodev,			/* cb_aread */
278 	nodev			/* cb_awrite */
279 };
280 
281 /*
282  * dev_ops contains configuration routines
283  */
284 static struct dev_ops mrsas_ops = {
285 	DEVO_REV,		/* rev, */
286 	0,			/* refcnt */
287 	mrsas_getinfo,		/* getinfo */
288 	nulldev,		/* identify */
289 	nulldev,		/* probe */
290 	mrsas_attach,		/* attach */
291 	mrsas_detach,		/* detach */
292 #ifdef	__sparc
293 	mrsas_reset,		/* reset */
294 #else	/* __sparc */
295 	nodev,
296 #endif	/* __sparc */
297 	&mrsas_cb_ops,		/* char/block ops */
298 	NULL,			/* bus ops */
299 	NULL,			/* power */
300 #ifdef __sparc
301 	ddi_quiesce_not_needed
302 #else	/* __sparc */
303 	mrsas_quiesce	/* quiesce */
304 #endif	/* __sparc */
305 };
306 
307 static struct modldrv modldrv = {
308 	&mod_driverops,		/* module type - driver */
309 	MRSAS_VERSION,
310 	&mrsas_ops,		/* driver ops */
311 };
312 
313 static struct modlinkage modlinkage = {
314 	MODREV_1,	/* ml_rev - must be MODREV_1 */
315 	&modldrv,	/* ml_linkage */
316 	NULL		/* end of driver linkage */
317 };
318 
319 static struct ddi_device_acc_attr endian_attr = {
320 	DDI_DEVICE_ATTR_V1,
321 	DDI_STRUCTURE_LE_ACC,
322 	DDI_STRICTORDER_ACC,
323 	DDI_DEFAULT_ACC
324 };
325 
326 /* Use the LSI Fast Path for the 2208 (tbolt) commands. */
327 unsigned int enable_fp = 1;
328 
329 
330 /*
331  * ************************************************************************** *
332  *									      *
333  *	   common entry points - for loadable kernel modules		      *
334  *									      *
335  * ************************************************************************** *
336  */
337 
338 /*
339  * _init - initialize a loadable module
340  * @void
341  *
342  * The driver should perform any one-time resource allocation or data
343  * initialization during driver loading in _init(). For example, the driver
344  * should initialize any mutexes global to the driver in this routine.
345  * The driver should not, however, use _init() to allocate or initialize
346  * anything that has to do with a particular instance of the device.
347  * Per-instance initialization must be done in attach().
348  */
349 int
_init(void)350 _init(void)
351 {
352 	int ret;
353 
354 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
355 
356 	ret = ddi_soft_state_init(&mrsas_state,
357 	    sizeof (struct mrsas_instance), 0);
358 
359 	if (ret != DDI_SUCCESS) {
360 		cmn_err(CE_WARN, "mr_sas: could not init state");
361 		return (ret);
362 	}
363 
364 	if ((ret = scsi_hba_init(&modlinkage)) != DDI_SUCCESS) {
365 		cmn_err(CE_WARN, "mr_sas: could not init scsi hba");
366 		ddi_soft_state_fini(&mrsas_state);
367 		return (ret);
368 	}
369 
370 	ret = mod_install(&modlinkage);
371 
372 	if (ret != DDI_SUCCESS) {
373 		cmn_err(CE_WARN, "mr_sas: mod_install failed");
374 		scsi_hba_fini(&modlinkage);
375 		ddi_soft_state_fini(&mrsas_state);
376 	}
377 
378 	return (ret);
379 }
380 
381 /*
382  * _info - returns information about a loadable module.
383  * @void
384  *
385  * _info() is called to return module information. This is a typical entry
386  * point that does predefined role. It simply calls mod_info().
387  */
388 int
_info(struct modinfo * modinfop)389 _info(struct modinfo *modinfop)
390 {
391 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
392 
393 	return (mod_info(&modlinkage, modinfop));
394 }
395 
396 /*
397  * _fini - prepare a loadable module for unloading
398  * @void
399  *
400  * In _fini(), the driver should release any resources that were allocated in
401  * _init(). The driver must remove itself from the system module list.
402  */
403 int
_fini(void)404 _fini(void)
405 {
406 	int ret;
407 
408 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
409 
410 	if ((ret = mod_remove(&modlinkage)) != DDI_SUCCESS) {
411 		con_log(CL_ANN1,
412 		    (CE_WARN, "_fini: mod_remove() failed, error 0x%X", ret));
413 		return (ret);
414 	}
415 
416 	scsi_hba_fini(&modlinkage);
417 	con_log(CL_DLEVEL1, (CE_NOTE, "_fini: scsi_hba_fini() done."));
418 
419 	ddi_soft_state_fini(&mrsas_state);
420 	con_log(CL_DLEVEL1, (CE_NOTE, "_fini: ddi_soft_state_fini() done."));
421 
422 	return (ret);
423 }
424 
425 
426 /*
427  * ************************************************************************** *
428  *									      *
429  *		 common entry points - for autoconfiguration		      *
430  *									      *
431  * ************************************************************************** *
432  */
433 /*
434  * attach - adds a device to the system as part of initialization
435  * @dip:
436  * @cmd:
437  *
438  * The kernel calls a driver's attach() entry point to attach an instance of
439  * a device (for MegaRAID, it is instance of a controller) or to resume
440  * operation for an instance of a device that has been suspended or has been
441  * shut down by the power management framework
442  * The attach() entry point typically includes the following types of
443  * processing:
444  * - allocate a soft-state structure for the device instance (for MegaRAID,
445  *   controller instance)
446  * - initialize per-instance mutexes
447  * - initialize condition variables
448  * - register the device's interrupts (for MegaRAID, controller's interrupts)
449  * - map the registers and memory of the device instance (for MegaRAID,
450  *   controller instance)
451  * - create minor device nodes for the device instance (for MegaRAID,
452  *   controller instance)
453  * - report that the device instance (for MegaRAID, controller instance) has
454  *   attached
455  */
456 static int
mrsas_attach(dev_info_t * dip,ddi_attach_cmd_t cmd)457 mrsas_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
458 {
459 	int		instance_no;
460 	int		nregs;
461 	int		i = 0;
462 	uint8_t		irq;
463 	uint16_t	vendor_id;
464 	uint16_t	device_id;
465 	uint16_t	subsysvid;
466 	uint16_t	subsysid;
467 	uint16_t	command;
468 	off_t		reglength = 0;
469 	int		intr_types = 0;
470 	char		*data;
471 
472 	scsi_hba_tran_t		*tran;
473 	ddi_dma_attr_t	tran_dma_attr;
474 	struct mrsas_instance	*instance;
475 
476 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
477 
478 	/* CONSTCOND */
479 	ASSERT(NO_COMPETING_THREADS);
480 
481 	instance_no = ddi_get_instance(dip);
482 
483 	/*
484 	 * check to see whether this device is in a DMA-capable slot.
485 	 */
486 	if (ddi_slaveonly(dip) == DDI_SUCCESS) {
487 		dev_err(dip, CE_WARN, "Device in slave-only slot, unused");
488 		return (DDI_FAILURE);
489 	}
490 
491 	switch (cmd) {
492 	case DDI_ATTACH:
493 		/* allocate the soft state for the instance */
494 		if (ddi_soft_state_zalloc(mrsas_state, instance_no)
495 		    != DDI_SUCCESS) {
496 			dev_err(dip, CE_WARN, "Failed to allocate soft state");
497 			return (DDI_FAILURE);
498 		}
499 
500 		instance = (struct mrsas_instance *)ddi_get_soft_state
501 		    (mrsas_state, instance_no);
502 
503 		if (instance == NULL) {
504 			dev_err(dip, CE_WARN, "Bad soft state");
505 			ddi_soft_state_free(mrsas_state, instance_no);
506 			return (DDI_FAILURE);
507 		}
508 
509 		instance->unroll.softs	= 1;
510 
511 		/* Setup the PCI configuration space handles */
512 		if (pci_config_setup(dip, &instance->pci_handle) !=
513 		    DDI_SUCCESS) {
514 			dev_err(dip, CE_WARN, "pci config setup failed");
515 
516 			ddi_soft_state_free(mrsas_state, instance_no);
517 			return (DDI_FAILURE);
518 		}
519 
520 		if (ddi_dev_nregs(dip, &nregs) != DDI_SUCCESS) {
521 			dev_err(dip, CE_WARN, "Failed to get registers");
522 
523 			pci_config_teardown(&instance->pci_handle);
524 			ddi_soft_state_free(mrsas_state, instance_no);
525 			return (DDI_FAILURE);
526 		}
527 
528 		vendor_id = pci_config_get16(instance->pci_handle,
529 		    PCI_CONF_VENID);
530 		device_id = pci_config_get16(instance->pci_handle,
531 		    PCI_CONF_DEVID);
532 
533 		subsysvid = pci_config_get16(instance->pci_handle,
534 		    PCI_CONF_SUBVENID);
535 		subsysid = pci_config_get16(instance->pci_handle,
536 		    PCI_CONF_SUBSYSID);
537 
538 		pci_config_put16(instance->pci_handle, PCI_CONF_COMM,
539 		    (pci_config_get16(instance->pci_handle,
540 		    PCI_CONF_COMM) | PCI_COMM_ME));
541 		irq = pci_config_get8(instance->pci_handle,
542 		    PCI_CONF_ILINE);
543 
544 		dev_err(dip, CE_CONT,
545 		    "?0x%x:0x%x 0x%x:0x%x, irq:%d drv-ver:%s\n",
546 		    vendor_id, device_id, subsysvid,
547 		    subsysid, irq, MRSAS_VERSION);
548 
549 		/* enable bus-mastering */
550 		command = pci_config_get16(instance->pci_handle,
551 		    PCI_CONF_COMM);
552 
553 		if (!(command & PCI_COMM_ME)) {
554 			command |= PCI_COMM_ME;
555 
556 			pci_config_put16(instance->pci_handle,
557 			    PCI_CONF_COMM, command);
558 
559 			con_log(CL_ANN, (CE_CONT, "mr_sas%d: "
560 			    "enable bus-mastering", instance_no));
561 		} else {
562 			con_log(CL_DLEVEL1, (CE_CONT, "mr_sas%d: "
563 			    "bus-mastering already set", instance_no));
564 		}
565 
566 		/* initialize function pointers */
567 		switch (device_id) {
568 		case PCI_DEVICE_ID_LSI_INVADER:
569 		case PCI_DEVICE_ID_LSI_FURY:
570 		case PCI_DEVICE_ID_LSI_INTRUDER:
571 		case PCI_DEVICE_ID_LSI_INTRUDER_24:
572 		case PCI_DEVICE_ID_LSI_CUTLASS_52:
573 		case PCI_DEVICE_ID_LSI_CUTLASS_53:
574 			dev_err(dip, CE_CONT, "?Gen3 device detected\n");
575 			instance->gen3 = 1;
576 			/* FALLTHROUGH */
577 		case PCI_DEVICE_ID_LSI_TBOLT:
578 			dev_err(dip, CE_CONT, "?TBOLT device detected\n");
579 
580 			instance->func_ptr =
581 			    &mrsas_function_template_fusion;
582 			instance->tbolt = 1;
583 			break;
584 
585 		case PCI_DEVICE_ID_LSI_SKINNY:
586 		case PCI_DEVICE_ID_LSI_SKINNY_NEW:
587 			/*
588 			 * FALLTHRU to PPC-style functions, but mark this
589 			 * instance as Skinny, because the register set is
590 			 * slightly different (See WR_IB_PICK_QPORT), and
591 			 * certain other features are available to a Skinny
592 			 * HBA.
593 			 */
594 			dev_err(dip, CE_CONT, "?Skinny device detected\n");
595 			instance->skinny = 1;
596 			/* FALLTHRU */
597 
598 		case PCI_DEVICE_ID_LSI_2108VDE:
599 		case PCI_DEVICE_ID_LSI_2108V:
600 			dev_err(dip, CE_CONT,
601 			    "?2108 Liberator device detected\n");
602 
603 			instance->func_ptr =
604 			    &mrsas_function_template_ppc;
605 			break;
606 
607 		default:
608 			dev_err(dip, CE_WARN, "Invalid device detected");
609 
610 			pci_config_teardown(&instance->pci_handle);
611 			ddi_soft_state_free(mrsas_state, instance_no);
612 			return (DDI_FAILURE);
613 		}
614 
615 		instance->baseaddress = pci_config_get32(
616 		    instance->pci_handle, PCI_CONF_BASE0);
617 		instance->baseaddress &= 0x0fffc;
618 
619 		instance->dip		= dip;
620 		instance->vendor_id	= vendor_id;
621 		instance->device_id	= device_id;
622 		instance->subsysvid	= subsysvid;
623 		instance->subsysid	= subsysid;
624 		instance->instance	= instance_no;
625 
626 		/* Initialize FMA */
627 		instance->fm_capabilities = ddi_prop_get_int(
628 		    DDI_DEV_T_ANY, instance->dip, DDI_PROP_DONTPASS,
629 		    "fm-capable", DDI_FM_EREPORT_CAPABLE |
630 		    DDI_FM_ACCCHK_CAPABLE | DDI_FM_DMACHK_CAPABLE
631 		    | DDI_FM_ERRCB_CAPABLE);
632 
633 		mrsas_fm_init(instance);
634 
635 		/* Setup register map */
636 		if ((ddi_dev_regsize(instance->dip,
637 		    REGISTER_SET_IO_2108, &reglength) != DDI_SUCCESS) ||
638 		    reglength < MINIMUM_MFI_MEM_SZ) {
639 			goto fail_attach;
640 		}
641 		if (reglength > DEFAULT_MFI_MEM_SZ) {
642 			reglength = DEFAULT_MFI_MEM_SZ;
643 			con_log(CL_DLEVEL1, (CE_NOTE,
644 			    "mr_sas: register length to map is 0x%lx bytes",
645 			    reglength));
646 		}
647 		if (ddi_regs_map_setup(instance->dip,
648 		    REGISTER_SET_IO_2108, &instance->regmap, 0,
649 		    reglength, &endian_attr, &instance->regmap_handle)
650 		    != DDI_SUCCESS) {
651 			dev_err(dip, CE_WARN, "couldn't map control registers");
652 			goto fail_attach;
653 		}
654 
655 		instance->unroll.regs = 1;
656 
657 		/*
658 		 * Disable Interrupt Now.
659 		 * Setup Software interrupt
660 		 */
661 		instance->func_ptr->disable_intr(instance);
662 
663 		if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0,
664 		    "mrsas-enable-msi", &data) == DDI_SUCCESS) {
665 			if (strncmp(data, "no", 3) == 0) {
666 				msi_enable = 0;
667 				con_log(CL_ANN1, (CE_WARN,
668 				    "msi_enable = %d disabled", msi_enable));
669 			}
670 			ddi_prop_free(data);
671 		}
672 
673 		dev_err(dip, CE_CONT, "?msi_enable = %d\n", msi_enable);
674 
675 		if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0,
676 		    "mrsas-enable-fp", &data) == DDI_SUCCESS) {
677 			if (strncmp(data, "no", 3) == 0) {
678 				enable_fp = 0;
679 				dev_err(dip, CE_NOTE,
680 				    "enable_fp = %d, Fast-Path disabled.\n",
681 				    enable_fp);
682 			}
683 
684 			ddi_prop_free(data);
685 		}
686 
687 		dev_err(dip, CE_CONT, "?enable_fp = %d\n", enable_fp);
688 
689 		/* Check for all supported interrupt types */
690 		if (ddi_intr_get_supported_types(
691 		    dip, &intr_types) != DDI_SUCCESS) {
692 			dev_err(dip, CE_WARN,
693 			    "ddi_intr_get_supported_types() failed");
694 			goto fail_attach;
695 		}
696 
697 		con_log(CL_DLEVEL1, (CE_NOTE,
698 		    "ddi_intr_get_supported_types() ret: 0x%x", intr_types));
699 
700 		/* Initialize and Setup Interrupt handler */
701 		if (msi_enable && (intr_types & DDI_INTR_TYPE_MSIX)) {
702 			if (mrsas_add_intrs(instance, DDI_INTR_TYPE_MSIX) !=
703 			    DDI_SUCCESS) {
704 				dev_err(dip, CE_WARN,
705 				    "MSIX interrupt query failed");
706 				goto fail_attach;
707 			}
708 			instance->intr_type = DDI_INTR_TYPE_MSIX;
709 		} else if (msi_enable && (intr_types & DDI_INTR_TYPE_MSI)) {
710 			if (mrsas_add_intrs(instance, DDI_INTR_TYPE_MSI) !=
711 			    DDI_SUCCESS) {
712 				dev_err(dip, CE_WARN,
713 				    "MSI interrupt query failed");
714 				goto fail_attach;
715 			}
716 			instance->intr_type = DDI_INTR_TYPE_MSI;
717 		} else if (intr_types & DDI_INTR_TYPE_FIXED) {
718 			msi_enable = 0;
719 			if (mrsas_add_intrs(instance, DDI_INTR_TYPE_FIXED) !=
720 			    DDI_SUCCESS) {
721 				dev_err(dip, CE_WARN,
722 				    "FIXED interrupt query failed");
723 				goto fail_attach;
724 			}
725 			instance->intr_type = DDI_INTR_TYPE_FIXED;
726 		} else {
727 			dev_err(dip, CE_WARN, "Device cannot "
728 			    "suppport either FIXED or MSI/X "
729 			    "interrupts");
730 			goto fail_attach;
731 		}
732 
733 		instance->unroll.intr = 1;
734 
735 		if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0,
736 		    "mrsas-enable-ctio", &data) == DDI_SUCCESS) {
737 			if (strncmp(data, "no", 3) == 0) {
738 				ctio_enable = 0;
739 				con_log(CL_ANN1, (CE_WARN,
740 				    "ctio_enable = %d disabled", ctio_enable));
741 			}
742 			ddi_prop_free(data);
743 		}
744 
745 		dev_err(dip, CE_CONT, "?ctio_enable = %d\n", ctio_enable);
746 
747 		/* setup the mfi based low level driver */
748 		if (mrsas_init_adapter(instance) != DDI_SUCCESS) {
749 			dev_err(dip, CE_WARN,
750 			    "could not initialize the low level driver");
751 
752 			goto fail_attach;
753 		}
754 
755 		/* Initialize all Mutex */
756 		INIT_LIST_HEAD(&instance->completed_pool_list);
757 		mutex_init(&instance->completed_pool_mtx, NULL,
758 		    MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
759 
760 		mutex_init(&instance->sync_map_mtx, NULL,
761 		    MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
762 
763 		mutex_init(&instance->app_cmd_pool_mtx, NULL,
764 		    MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
765 
766 		mutex_init(&instance->config_dev_mtx, NULL,
767 		    MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
768 
769 		mutex_init(&instance->cmd_pend_mtx, NULL,
770 		    MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
771 
772 		mutex_init(&instance->ocr_flags_mtx, NULL,
773 		    MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
774 
775 		mutex_init(&instance->int_cmd_mtx, NULL,
776 		    MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
777 		cv_init(&instance->int_cmd_cv, NULL, CV_DRIVER, NULL);
778 
779 		mutex_init(&instance->cmd_pool_mtx, NULL,
780 		    MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
781 
782 		mutex_init(&instance->reg_write_mtx, NULL,
783 		    MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
784 
785 		if (instance->tbolt) {
786 			mutex_init(&instance->cmd_app_pool_mtx, NULL,
787 			    MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
788 
789 			mutex_init(&instance->chip_mtx, NULL,
790 			    MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
791 
792 		}
793 
794 		instance->unroll.mutexs = 1;
795 
796 		instance->timeout_id = (timeout_id_t)-1;
797 
798 		/* Register our soft-isr for highlevel interrupts. */
799 		instance->isr_level = instance->intr_pri;
800 		if (!(instance->tbolt)) {
801 			if (instance->isr_level == HIGH_LEVEL_INTR) {
802 				if (ddi_add_softintr(dip,
803 				    DDI_SOFTINT_HIGH,
804 				    &instance->soft_intr_id, NULL, NULL,
805 				    mrsas_softintr, (caddr_t)instance) !=
806 				    DDI_SUCCESS) {
807 					dev_err(dip, CE_WARN,
808 					    "Software ISR did not register");
809 
810 					goto fail_attach;
811 				}
812 
813 				instance->unroll.soft_isr = 1;
814 
815 			}
816 		}
817 
818 		instance->softint_running = 0;
819 
820 		/* Allocate a transport structure */
821 		tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
822 
823 		if (tran == NULL) {
824 			dev_err(dip, CE_WARN,
825 			    "scsi_hba_tran_alloc failed");
826 			goto fail_attach;
827 		}
828 
829 		instance->tran = tran;
830 		instance->unroll.tran = 1;
831 
832 		tran->tran_hba_private	= instance;
833 		tran->tran_tgt_init	= mrsas_tran_tgt_init;
834 		tran->tran_tgt_probe	= scsi_hba_probe;
835 		tran->tran_tgt_free	= mrsas_tran_tgt_free;
836 		tran->tran_init_pkt	= mrsas_tran_init_pkt;
837 		if (instance->tbolt)
838 			tran->tran_start = mrsas_tbolt_tran_start;
839 		else
840 			tran->tran_start = mrsas_tran_start;
841 		tran->tran_abort	= mrsas_tran_abort;
842 		tran->tran_reset	= mrsas_tran_reset;
843 		tran->tran_getcap	= mrsas_tran_getcap;
844 		tran->tran_setcap	= mrsas_tran_setcap;
845 		tran->tran_destroy_pkt	= mrsas_tran_destroy_pkt;
846 		tran->tran_dmafree	= mrsas_tran_dmafree;
847 		tran->tran_sync_pkt	= mrsas_tran_sync_pkt;
848 		tran->tran_quiesce	= mrsas_tran_quiesce;
849 		tran->tran_unquiesce	= mrsas_tran_unquiesce;
850 		tran->tran_bus_config	= mrsas_tran_bus_config;
851 
852 		if (mrsas_relaxed_ordering)
853 			mrsas_generic_dma_attr.dma_attr_flags |=
854 			    DDI_DMA_RELAXED_ORDERING;
855 
856 
857 		tran_dma_attr = mrsas_generic_dma_attr;
858 		tran_dma_attr.dma_attr_sgllen = instance->max_num_sge;
859 
860 		/* Attach this instance of the hba */
861 		if (scsi_hba_attach_setup(dip, &tran_dma_attr, tran, 0)
862 		    != DDI_SUCCESS) {
863 			dev_err(dip, CE_WARN,
864 			    "scsi_hba_attach failed");
865 
866 			goto fail_attach;
867 		}
868 		instance->unroll.tranSetup = 1;
869 		con_log(CL_ANN1,
870 		    (CE_CONT, "scsi_hba_attach_setup()	done."));
871 
872 		/* create devctl node for cfgadm command */
873 		if (ddi_create_minor_node(dip, "devctl",
874 		    S_IFCHR, INST2DEVCTL(instance_no),
875 		    DDI_NT_SCSI_NEXUS, 0) == DDI_FAILURE) {
876 			dev_err(dip, CE_WARN, "failed to create devctl node.");
877 
878 			goto fail_attach;
879 		}
880 
881 		instance->unroll.devctl = 1;
882 
883 		/* create scsi node for cfgadm command */
884 		if (ddi_create_minor_node(dip, "scsi", S_IFCHR,
885 		    INST2SCSI(instance_no), DDI_NT_SCSI_ATTACHMENT_POINT, 0) ==
886 		    DDI_FAILURE) {
887 			dev_err(dip, CE_WARN, "failed to create scsi node.");
888 
889 			goto fail_attach;
890 		}
891 
892 		instance->unroll.scsictl = 1;
893 
894 		(void) snprintf(instance->iocnode, sizeof (instance->iocnode),
895 		    "%d:lsirdctl", instance_no);
896 
897 		/*
898 		 * Create a node for applications
899 		 * for issuing ioctl to the driver.
900 		 */
901 		if (ddi_create_minor_node(dip, instance->iocnode,
902 		    S_IFCHR, INST2LSIRDCTL(instance_no), DDI_PSEUDO, 0) ==
903 		    DDI_FAILURE) {
904 			dev_err(dip, CE_WARN, "failed to create ioctl node.");
905 
906 			goto fail_attach;
907 		}
908 
909 		instance->unroll.ioctl = 1;
910 
911 		/* Create a taskq to handle dr events */
912 		if ((instance->taskq = ddi_taskq_create(dip,
913 		    "mrsas_dr_taskq", 1, TASKQ_DEFAULTPRI, 0)) == NULL) {
914 			dev_err(dip, CE_WARN, "failed to create taskq.");
915 			instance->taskq = NULL;
916 			goto fail_attach;
917 		}
918 		instance->unroll.taskq = 1;
919 		con_log(CL_ANN1, (CE_CONT, "ddi_taskq_create() done."));
920 
921 		/* enable interrupt */
922 		instance->func_ptr->enable_intr(instance);
923 
924 		/* initiate AEN */
925 		if (start_mfi_aen(instance)) {
926 			dev_err(dip, CE_WARN, "failed to initiate AEN.");
927 			goto fail_attach;
928 		}
929 		instance->unroll.aenPend = 1;
930 		con_log(CL_ANN1,
931 		    (CE_CONT, "AEN started for instance %d.", instance_no));
932 
933 		/* Finally! We are on the air.	*/
934 		ddi_report_dev(dip);
935 
936 		/* FMA handle checking. */
937 		if (mrsas_check_acc_handle(instance->regmap_handle) !=
938 		    DDI_SUCCESS) {
939 			goto fail_attach;
940 		}
941 		if (mrsas_check_acc_handle(instance->pci_handle) !=
942 		    DDI_SUCCESS) {
943 			goto fail_attach;
944 		}
945 
946 		instance->mr_ld_list =
947 		    kmem_zalloc(MRDRV_MAX_LD * sizeof (struct mrsas_ld),
948 		    KM_SLEEP);
949 		instance->unroll.ldlist_buff = 1;
950 
951 		if (instance->tbolt || instance->skinny) {
952 			instance->mr_tbolt_pd_max = MRSAS_TBOLT_PD_TGT_MAX;
953 			instance->mr_tbolt_pd_list =
954 			    kmem_zalloc(MRSAS_TBOLT_GET_PD_MAX(instance) *
955 			    sizeof (struct mrsas_tbolt_pd), KM_SLEEP);
956 			ASSERT(instance->mr_tbolt_pd_list);
957 			for (i = 0; i < instance->mr_tbolt_pd_max; i++) {
958 				instance->mr_tbolt_pd_list[i].lun_type =
959 				    MRSAS_TBOLT_PD_LUN;
960 				instance->mr_tbolt_pd_list[i].dev_id =
961 				    (uint8_t)i;
962 			}
963 
964 			instance->unroll.pdlist_buff = 1;
965 		}
966 		break;
967 	case DDI_PM_RESUME:
968 		con_log(CL_ANN, (CE_NOTE, "mr_sas: DDI_PM_RESUME"));
969 		break;
970 	case DDI_RESUME:
971 		con_log(CL_ANN, (CE_NOTE, "mr_sas: DDI_RESUME"));
972 		break;
973 	default:
974 		con_log(CL_ANN,
975 		    (CE_WARN, "mr_sas: invalid attach cmd=%x", cmd));
976 		return (DDI_FAILURE);
977 	}
978 
979 
980 	con_log(CL_DLEVEL1,
981 	    (CE_NOTE, "mrsas_attach() return SUCCESS instance_num %d",
982 	    instance_no));
983 	return (DDI_SUCCESS);
984 
985 fail_attach:
986 
987 	mrsas_undo_resources(dip, instance);
988 
989 	mrsas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
990 	ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
991 
992 	mrsas_fm_fini(instance);
993 
994 	pci_config_teardown(&instance->pci_handle);
995 	ddi_soft_state_free(mrsas_state, instance_no);
996 
997 	return (DDI_FAILURE);
998 }
999 
1000 /*
1001  * getinfo - gets device information
1002  * @dip:
1003  * @cmd:
1004  * @arg:
1005  * @resultp:
1006  *
1007  * The system calls getinfo() to obtain configuration information that only
1008  * the driver knows. The mapping of minor numbers to device instance is
1009  * entirely under the control of the driver. The system sometimes needs to ask
1010  * the driver which device a particular dev_t represents.
1011  * Given the device number return the devinfo pointer from the scsi_device
1012  * structure.
1013  */
1014 /*ARGSUSED*/
1015 static int
mrsas_getinfo(dev_info_t * dip,ddi_info_cmd_t cmd,void * arg,void ** resultp)1016 mrsas_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,  void *arg, void **resultp)
1017 {
1018 	int	rval;
1019 	int	mrsas_minor = getminor((dev_t)arg);
1020 
1021 	struct mrsas_instance	*instance;
1022 
1023 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1024 
1025 	switch (cmd) {
1026 		case DDI_INFO_DEVT2DEVINFO:
1027 			instance = (struct mrsas_instance *)
1028 			    ddi_get_soft_state(mrsas_state,
1029 			    MINOR2INST(mrsas_minor));
1030 
1031 			if (instance == NULL) {
1032 				*resultp = NULL;
1033 				rval = DDI_FAILURE;
1034 			} else {
1035 				*resultp = instance->dip;
1036 				rval = DDI_SUCCESS;
1037 			}
1038 			break;
1039 		case DDI_INFO_DEVT2INSTANCE:
1040 			*resultp = (void *)(intptr_t)
1041 			    (MINOR2INST(getminor((dev_t)arg)));
1042 			rval = DDI_SUCCESS;
1043 			break;
1044 		default:
1045 			*resultp = NULL;
1046 			rval = DDI_FAILURE;
1047 	}
1048 
1049 	return (rval);
1050 }
1051 
1052 /*
1053  * detach - detaches a device from the system
1054  * @dip: pointer to the device's dev_info structure
1055  * @cmd: type of detach
1056  *
1057  * A driver's detach() entry point is called to detach an instance of a device
1058  * that is bound to the driver. The entry point is called with the instance of
1059  * the device node to be detached and with DDI_DETACH, which is specified as
1060  * the cmd argument to the entry point.
1061  * This routine is called during driver unload. We free all the allocated
1062  * resources and call the corresponding LLD so that it can also release all
1063  * its resources.
1064  */
1065 static int
mrsas_detach(dev_info_t * dip,ddi_detach_cmd_t cmd)1066 mrsas_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1067 {
1068 	int	instance_no;
1069 
1070 	struct mrsas_instance	*instance;
1071 
1072 	con_log(CL_ANN, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1073 
1074 
1075 	/* CONSTCOND */
1076 	ASSERT(NO_COMPETING_THREADS);
1077 
1078 	instance_no = ddi_get_instance(dip);
1079 
1080 	instance = (struct mrsas_instance *)ddi_get_soft_state(mrsas_state,
1081 	    instance_no);
1082 
1083 	if (!instance) {
1084 		dev_err(dip, CE_WARN, "could not get instance in detach");
1085 
1086 		return (DDI_FAILURE);
1087 	}
1088 
1089 	switch (cmd) {
1090 		case DDI_DETACH:
1091 			con_log(CL_ANN, (CE_NOTE,
1092 			    "mrsas_detach: DDI_DETACH"));
1093 
1094 			mutex_enter(&instance->config_dev_mtx);
1095 			if (instance->timeout_id != (timeout_id_t)-1) {
1096 				mutex_exit(&instance->config_dev_mtx);
1097 				(void) untimeout(instance->timeout_id);
1098 				instance->timeout_id = (timeout_id_t)-1;
1099 				mutex_enter(&instance->config_dev_mtx);
1100 				instance->unroll.timer = 0;
1101 			}
1102 			mutex_exit(&instance->config_dev_mtx);
1103 
1104 			if (instance->unroll.tranSetup == 1) {
1105 				if (scsi_hba_detach(dip) != DDI_SUCCESS) {
1106 					dev_err(dip, CE_WARN,
1107 					    "failed to detach");
1108 					return (DDI_FAILURE);
1109 				}
1110 				instance->unroll.tranSetup = 0;
1111 				con_log(CL_ANN1,
1112 				    (CE_CONT, "scsi_hba_dettach()  done."));
1113 			}
1114 
1115 			flush_cache(instance);
1116 
1117 			mrsas_undo_resources(dip, instance);
1118 
1119 			mrsas_fm_fini(instance);
1120 
1121 			pci_config_teardown(&instance->pci_handle);
1122 			ddi_soft_state_free(mrsas_state, instance_no);
1123 			break;
1124 
1125 		case DDI_PM_SUSPEND:
1126 			con_log(CL_ANN, (CE_NOTE,
1127 			    "mrsas_detach: DDI_PM_SUSPEND"));
1128 
1129 			break;
1130 		case DDI_SUSPEND:
1131 			con_log(CL_ANN, (CE_NOTE,
1132 			    "mrsas_detach: DDI_SUSPEND"));
1133 
1134 			break;
1135 		default:
1136 			con_log(CL_ANN, (CE_WARN,
1137 			    "invalid detach command:0x%x", cmd));
1138 			return (DDI_FAILURE);
1139 	}
1140 
1141 	return (DDI_SUCCESS);
1142 }
1143 
1144 
1145 static void
mrsas_undo_resources(dev_info_t * dip,struct mrsas_instance * instance)1146 mrsas_undo_resources(dev_info_t *dip, struct mrsas_instance *instance)
1147 {
1148 	con_log(CL_ANN, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1149 
1150 	if (instance->unroll.ioctl == 1) {
1151 		ddi_remove_minor_node(dip, instance->iocnode);
1152 		instance->unroll.ioctl = 0;
1153 	}
1154 
1155 	if (instance->unroll.scsictl == 1) {
1156 		ddi_remove_minor_node(dip, "scsi");
1157 		instance->unroll.scsictl = 0;
1158 	}
1159 
1160 	if (instance->unroll.devctl == 1) {
1161 		ddi_remove_minor_node(dip, "devctl");
1162 		instance->unroll.devctl = 0;
1163 	}
1164 
1165 	if (instance->unroll.tranSetup == 1) {
1166 		if (scsi_hba_detach(dip) != DDI_SUCCESS) {
1167 			dev_err(dip, CE_WARN, "failed to detach");
1168 			return;	 /* DDI_FAILURE */
1169 		}
1170 		instance->unroll.tranSetup = 0;
1171 		con_log(CL_ANN1, (CE_CONT, "scsi_hba_dettach()	done."));
1172 	}
1173 
1174 	if (instance->unroll.tran == 1)	 {
1175 		scsi_hba_tran_free(instance->tran);
1176 		instance->unroll.tran = 0;
1177 		con_log(CL_ANN1, (CE_CONT, "scsi_hba_tran_free()  done."));
1178 	}
1179 
1180 	if (instance->unroll.syncCmd == 1) {
1181 		if (instance->tbolt) {
1182 			if (abort_syncmap_cmd(instance,
1183 			    instance->map_update_cmd)) {
1184 				dev_err(dip, CE_WARN, "mrsas_detach: "
1185 				    "failed to abort previous syncmap command");
1186 			}
1187 
1188 			instance->unroll.syncCmd = 0;
1189 			con_log(CL_ANN1, (CE_CONT, "sync cmd aborted, done."));
1190 		}
1191 	}
1192 
1193 	if (instance->unroll.aenPend == 1) {
1194 		if (abort_aen_cmd(instance, instance->aen_cmd))
1195 			dev_err(dip, CE_WARN, "mrsas_detach: "
1196 			    "failed to abort prevous AEN command");
1197 
1198 		instance->unroll.aenPend = 0;
1199 		con_log(CL_ANN1, (CE_CONT, "aen cmd aborted, done."));
1200 		/* This means the controller is fully initialized and running */
1201 		/* Shutdown should be a last command to controller. */
1202 		/* shutdown_controller(); */
1203 	}
1204 
1205 
1206 	if (instance->unroll.timer == 1)	 {
1207 		if (instance->timeout_id != (timeout_id_t)-1) {
1208 			(void) untimeout(instance->timeout_id);
1209 			instance->timeout_id = (timeout_id_t)-1;
1210 
1211 			instance->unroll.timer = 0;
1212 		}
1213 	}
1214 
1215 	instance->func_ptr->disable_intr(instance);
1216 
1217 
1218 	if (instance->unroll.mutexs == 1) {
1219 		mutex_destroy(&instance->cmd_pool_mtx);
1220 		mutex_destroy(&instance->app_cmd_pool_mtx);
1221 		mutex_destroy(&instance->cmd_pend_mtx);
1222 		mutex_destroy(&instance->completed_pool_mtx);
1223 		mutex_destroy(&instance->sync_map_mtx);
1224 		mutex_destroy(&instance->int_cmd_mtx);
1225 		cv_destroy(&instance->int_cmd_cv);
1226 		mutex_destroy(&instance->config_dev_mtx);
1227 		mutex_destroy(&instance->ocr_flags_mtx);
1228 		mutex_destroy(&instance->reg_write_mtx);
1229 
1230 		if (instance->tbolt) {
1231 			mutex_destroy(&instance->cmd_app_pool_mtx);
1232 			mutex_destroy(&instance->chip_mtx);
1233 		}
1234 
1235 		instance->unroll.mutexs = 0;
1236 		con_log(CL_ANN1, (CE_CONT, "Destroy mutex & cv,	 done."));
1237 	}
1238 
1239 
1240 	if (instance->unroll.soft_isr == 1) {
1241 		ddi_remove_softintr(instance->soft_intr_id);
1242 		instance->unroll.soft_isr = 0;
1243 	}
1244 
1245 	if (instance->unroll.intr == 1) {
1246 		mrsas_rem_intrs(instance);
1247 		instance->unroll.intr = 0;
1248 	}
1249 
1250 
1251 	if (instance->unroll.taskq == 1)	 {
1252 		if (instance->taskq) {
1253 			ddi_taskq_destroy(instance->taskq);
1254 			instance->unroll.taskq = 0;
1255 		}
1256 
1257 	}
1258 
1259 	/*
1260 	 * free dma memory allocated for
1261 	 * cmds/frames/queues/driver version etc
1262 	 */
1263 	if (instance->unroll.verBuff == 1) {
1264 		(void) mrsas_free_dma_obj(instance, instance->drv_ver_dma_obj);
1265 		instance->unroll.verBuff = 0;
1266 	}
1267 
1268 	if (instance->unroll.pdlist_buff == 1)	{
1269 		if (instance->mr_tbolt_pd_list != NULL) {
1270 			kmem_free(instance->mr_tbolt_pd_list,
1271 			    MRSAS_TBOLT_GET_PD_MAX(instance) *
1272 			    sizeof (struct mrsas_tbolt_pd));
1273 		}
1274 
1275 		instance->mr_tbolt_pd_list = NULL;
1276 		instance->unroll.pdlist_buff = 0;
1277 	}
1278 
1279 	if (instance->unroll.ldlist_buff == 1)	{
1280 		if (instance->mr_ld_list != NULL) {
1281 			kmem_free(instance->mr_ld_list, MRDRV_MAX_LD
1282 			    * sizeof (struct mrsas_ld));
1283 		}
1284 
1285 		instance->mr_ld_list = NULL;
1286 		instance->unroll.ldlist_buff = 0;
1287 	}
1288 
1289 	if (instance->tbolt) {
1290 		if (instance->unroll.alloc_space_mpi2 == 1) {
1291 			free_space_for_mpi2(instance);
1292 			instance->unroll.alloc_space_mpi2 = 0;
1293 		}
1294 	} else {
1295 		if (instance->unroll.alloc_space_mfi == 1) {
1296 			free_space_for_mfi(instance);
1297 			instance->unroll.alloc_space_mfi = 0;
1298 		}
1299 	}
1300 
1301 	if (instance->unroll.regs == 1)	 {
1302 		ddi_regs_map_free(&instance->regmap_handle);
1303 		instance->unroll.regs = 0;
1304 		con_log(CL_ANN1, (CE_CONT, "ddi_regs_map_free()	 done."));
1305 	}
1306 }
1307 
1308 
1309 
1310 /*
1311  * ************************************************************************** *
1312  *									      *
1313  *	       common entry points - for character driver types		      *
1314  *									      *
1315  * ************************************************************************** *
1316  */
1317 /*
1318  * open - gets access to a device
1319  * @dev:
1320  * @openflags:
1321  * @otyp:
1322  * @credp:
1323  *
1324  * Access to a device by one or more application programs is controlled
1325  * through the open() and close() entry points. The primary function of
1326  * open() is to verify that the open request is allowed.
1327  */
1328 static	int
mrsas_open(dev_t * dev,int openflags,int otyp,cred_t * credp)1329 mrsas_open(dev_t *dev, int openflags, int otyp, cred_t *credp)
1330 {
1331 	int	rval = 0;
1332 
1333 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1334 
1335 	/* Check root permissions */
1336 	if (drv_priv(credp) != 0) {
1337 		con_log(CL_ANN, (CE_WARN,
1338 		    "mr_sas: Non-root ioctl access denied!"));
1339 		return (EPERM);
1340 	}
1341 
1342 	/* Verify we are being opened as a character device */
1343 	if (otyp != OTYP_CHR) {
1344 		con_log(CL_ANN, (CE_WARN,
1345 		    "mr_sas: ioctl node must be a char node"));
1346 		return (EINVAL);
1347 	}
1348 
1349 	if (ddi_get_soft_state(mrsas_state, MINOR2INST(getminor(*dev)))
1350 	    == NULL) {
1351 		return (ENXIO);
1352 	}
1353 
1354 	if (scsi_hba_open) {
1355 		rval = scsi_hba_open(dev, openflags, otyp, credp);
1356 	}
1357 
1358 	return (rval);
1359 }
1360 
1361 /*
1362  * close - gives up access to a device
1363  * @dev:
1364  * @openflags:
1365  * @otyp:
1366  * @credp:
1367  *
1368  * close() should perform any cleanup necessary to finish using the minor
1369  * device, and prepare the device (and driver) to be opened again.
1370  */
1371 static	int
mrsas_close(dev_t dev,int openflags,int otyp,cred_t * credp)1372 mrsas_close(dev_t dev, int openflags, int otyp, cred_t *credp)
1373 {
1374 	int	rval = 0;
1375 
1376 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1377 
1378 	/* no need for locks! */
1379 
1380 	if (scsi_hba_close) {
1381 		rval = scsi_hba_close(dev, openflags, otyp, credp);
1382 	}
1383 
1384 	return (rval);
1385 }
1386 
1387 /*
1388  * ioctl - performs a range of I/O commands for character drivers
1389  * @dev:
1390  * @cmd:
1391  * @arg:
1392  * @mode:
1393  * @credp:
1394  * @rvalp:
1395  *
1396  * ioctl() routine must make sure that user data is copied into or out of the
1397  * kernel address space explicitly using copyin(), copyout(), ddi_copyin(),
1398  * and ddi_copyout(), as appropriate.
1399  * This is a wrapper routine to serialize access to the actual ioctl routine.
1400  * ioctl() should return 0 on success, or the appropriate error number. The
1401  * driver may also set the value returned to the calling process through rvalp.
1402  */
1403 
1404 static int
mrsas_ioctl(dev_t dev,int cmd,intptr_t arg,int mode,cred_t * credp,int * rvalp)1405 mrsas_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
1406     int *rvalp)
1407 {
1408 	int	rval = 0;
1409 
1410 	struct mrsas_instance	*instance;
1411 	struct mrsas_ioctl	*ioctl;
1412 	struct mrsas_aen	aen;
1413 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1414 
1415 	instance = ddi_get_soft_state(mrsas_state, MINOR2INST(getminor(dev)));
1416 
1417 	if (instance == NULL) {
1418 		/* invalid minor number */
1419 		con_log(CL_ANN, (CE_WARN, "mr_sas: adapter not found."));
1420 		return (ENXIO);
1421 	}
1422 
1423 	ioctl = (struct mrsas_ioctl *)kmem_zalloc(sizeof (struct mrsas_ioctl),
1424 	    KM_SLEEP);
1425 	ASSERT(ioctl);
1426 
1427 	switch ((uint_t)cmd) {
1428 		case MRSAS_IOCTL_FIRMWARE:
1429 			if (ddi_copyin((void *)arg, ioctl,
1430 			    sizeof (struct mrsas_ioctl), mode)) {
1431 				con_log(CL_ANN, (CE_WARN, "mrsas_ioctl: "
1432 				    "ERROR IOCTL copyin"));
1433 				kmem_free(ioctl, sizeof (struct mrsas_ioctl));
1434 				return (EFAULT);
1435 			}
1436 
1437 			if (ioctl->control_code == MRSAS_DRIVER_IOCTL_COMMON) {
1438 				rval = handle_drv_ioctl(instance, ioctl, mode);
1439 			} else {
1440 				rval = handle_mfi_ioctl(instance, ioctl, mode);
1441 			}
1442 
1443 			if (ddi_copyout((void *)ioctl, (void *)arg,
1444 			    (sizeof (struct mrsas_ioctl) - 1), mode)) {
1445 				con_log(CL_ANN, (CE_WARN,
1446 				    "mrsas_ioctl: copy_to_user failed"));
1447 				rval = 1;
1448 			}
1449 
1450 			break;
1451 		case MRSAS_IOCTL_AEN:
1452 			if (ddi_copyin((void *) arg, &aen,
1453 			    sizeof (struct mrsas_aen), mode)) {
1454 				con_log(CL_ANN, (CE_WARN,
1455 				    "mrsas_ioctl: ERROR AEN copyin"));
1456 				kmem_free(ioctl, sizeof (struct mrsas_ioctl));
1457 				return (EFAULT);
1458 			}
1459 
1460 			rval = handle_mfi_aen(instance, &aen);
1461 
1462 			if (ddi_copyout((void *) &aen, (void *)arg,
1463 			    sizeof (struct mrsas_aen), mode)) {
1464 				con_log(CL_ANN, (CE_WARN,
1465 				    "mrsas_ioctl: copy_to_user failed"));
1466 				rval = 1;
1467 			}
1468 
1469 			break;
1470 		default:
1471 			rval = scsi_hba_ioctl(dev, cmd, arg,
1472 			    mode, credp, rvalp);
1473 
1474 			con_log(CL_DLEVEL1, (CE_NOTE, "mrsas_ioctl: "
1475 			    "scsi_hba_ioctl called, ret = %x.", rval));
1476 	}
1477 
1478 	kmem_free(ioctl, sizeof (struct mrsas_ioctl));
1479 	return (rval);
1480 }
1481 
1482 /*
1483  * ************************************************************************** *
1484  *									      *
1485  *		 common entry points - for block driver types		      *
1486  *									      *
1487  * ************************************************************************** *
1488  */
1489 #ifdef __sparc
1490 /*
1491  * reset - TBD
1492  * @dip:
1493  * @cmd:
1494  *
1495  * TBD
1496  */
1497 /*ARGSUSED*/
1498 static int
mrsas_reset(dev_info_t * dip,ddi_reset_cmd_t cmd)1499 mrsas_reset(dev_info_t *dip, ddi_reset_cmd_t cmd)
1500 {
1501 	int	instance_no;
1502 
1503 	struct mrsas_instance	*instance;
1504 
1505 	instance_no = ddi_get_instance(dip);
1506 	instance = (struct mrsas_instance *)ddi_get_soft_state
1507 	    (mrsas_state, instance_no);
1508 
1509 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1510 
1511 	if (!instance) {
1512 		con_log(CL_ANN, (CE_WARN, "mr_sas:%d could not get adapter "
1513 		    "in reset", instance_no));
1514 		return (DDI_FAILURE);
1515 	}
1516 
1517 	instance->func_ptr->disable_intr(instance);
1518 
1519 	con_log(CL_ANN1, (CE_CONT, "flushing cache for instance %d",
1520 	    instance_no));
1521 
1522 	flush_cache(instance);
1523 
1524 	return (DDI_SUCCESS);
1525 }
1526 #else /* __sparc */
1527 /*ARGSUSED*/
1528 static int
mrsas_quiesce(dev_info_t * dip)1529 mrsas_quiesce(dev_info_t *dip)
1530 {
1531 	int	instance_no;
1532 
1533 	struct mrsas_instance	*instance;
1534 
1535 	instance_no = ddi_get_instance(dip);
1536 	instance = (struct mrsas_instance *)ddi_get_soft_state
1537 	    (mrsas_state, instance_no);
1538 
1539 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1540 
1541 	if (!instance) {
1542 		con_log(CL_ANN1, (CE_WARN, "mr_sas:%d could not get adapter "
1543 		    "in quiesce", instance_no));
1544 		return (DDI_FAILURE);
1545 	}
1546 	if (instance->deadadapter || instance->adapterresetinprogress) {
1547 		con_log(CL_ANN1, (CE_WARN, "mr_sas:%d adapter is not in "
1548 		    "healthy state", instance_no));
1549 		return (DDI_FAILURE);
1550 	}
1551 
1552 	if (abort_aen_cmd(instance, instance->aen_cmd)) {
1553 		con_log(CL_ANN1, (CE_WARN, "mrsas_quiesce: "
1554 		    "failed to abort prevous AEN command QUIESCE"));
1555 	}
1556 
1557 	if (instance->tbolt) {
1558 		if (abort_syncmap_cmd(instance,
1559 		    instance->map_update_cmd)) {
1560 			dev_err(dip, CE_WARN,
1561 			    "mrsas_detach: failed to abort "
1562 			    "previous syncmap command");
1563 			return (DDI_FAILURE);
1564 		}
1565 	}
1566 
1567 	instance->func_ptr->disable_intr(instance);
1568 
1569 	con_log(CL_ANN1, (CE_CONT, "flushing cache for instance %d",
1570 	    instance_no));
1571 
1572 	flush_cache(instance);
1573 
1574 	if (wait_for_outstanding(instance)) {
1575 		con_log(CL_ANN1,
1576 		    (CE_CONT, "wait_for_outstanding: return FAIL.\n"));
1577 		return (DDI_FAILURE);
1578 	}
1579 	return (DDI_SUCCESS);
1580 }
1581 #endif	/* __sparc */
1582 
1583 /*
1584  * ************************************************************************** *
1585  *									      *
1586  *			    entry points (SCSI HBA)			      *
1587  *									      *
1588  * ************************************************************************** *
1589  */
1590 /*
1591  * tran_tgt_init - initialize a target device instance
1592  * @hba_dip:
1593  * @tgt_dip:
1594  * @tran:
1595  * @sd:
1596  *
1597  * The tran_tgt_init() entry point enables the HBA to allocate and initialize
1598  * any per-target resources. tran_tgt_init() also enables the HBA to qualify
1599  * the device's address as valid and supportable for that particular HBA.
1600  * By returning DDI_FAILURE, the instance of the target driver for that device
1601  * is not probed or attached.
1602  */
1603 /*ARGSUSED*/
1604 static int
mrsas_tran_tgt_init(dev_info_t * hba_dip,dev_info_t * tgt_dip,scsi_hba_tran_t * tran,struct scsi_device * sd)1605 mrsas_tran_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
1606     scsi_hba_tran_t *tran, struct scsi_device *sd)
1607 {
1608 	struct mrsas_instance *instance;
1609 	uint16_t tgt = sd->sd_address.a_target;
1610 	uint8_t lun = sd->sd_address.a_lun;
1611 	dev_info_t *child = NULL;
1612 
1613 	con_log(CL_DLEVEL2, (CE_NOTE, "mrsas_tgt_init target %d lun %d",
1614 	    tgt, lun));
1615 
1616 	instance = ADDR2MR(&sd->sd_address);
1617 
1618 	if (ndi_dev_is_persistent_node(tgt_dip) == 0) {
1619 		/*
1620 		 * If no persistent node exists, we don't allow .conf node
1621 		 * to be created.
1622 		 */
1623 		if ((child = mrsas_find_child(instance, tgt, lun)) != NULL) {
1624 			con_log(CL_DLEVEL2,
1625 			    (CE_NOTE, "mrsas_tgt_init find child ="
1626 			    " %p t = %d l = %d", (void *)child, tgt, lun));
1627 			if (ndi_merge_node(tgt_dip, mrsas_name_node) !=
1628 			    DDI_SUCCESS)
1629 				/* Create this .conf node */
1630 				return (DDI_SUCCESS);
1631 		}
1632 		con_log(CL_DLEVEL2, (CE_NOTE, "mrsas_tgt_init in ndi_per "
1633 		    "DDI_FAILURE t = %d l = %d", tgt, lun));
1634 		return (DDI_FAILURE);
1635 
1636 	}
1637 
1638 	con_log(CL_DLEVEL2, (CE_NOTE, "mrsas_tgt_init dev_dip %p tgt_dip %p",
1639 	    (void *)instance->mr_ld_list[tgt].dip, (void *)tgt_dip));
1640 
1641 	if (tgt < MRDRV_MAX_LD && lun == 0) {
1642 		if (instance->mr_ld_list[tgt].dip == NULL &&
1643 		    strcmp(ddi_driver_name(sd->sd_dev), "sd") == 0) {
1644 			mutex_enter(&instance->config_dev_mtx);
1645 			instance->mr_ld_list[tgt].dip = tgt_dip;
1646 			instance->mr_ld_list[tgt].lun_type = MRSAS_LD_LUN;
1647 			instance->mr_ld_list[tgt].flag = MRDRV_TGT_VALID;
1648 			mutex_exit(&instance->config_dev_mtx);
1649 		}
1650 	} else if (instance->tbolt || instance->skinny) {
1651 		if (instance->mr_tbolt_pd_list[tgt].dip == NULL) {
1652 			mutex_enter(&instance->config_dev_mtx);
1653 			instance->mr_tbolt_pd_list[tgt].dip = tgt_dip;
1654 			instance->mr_tbolt_pd_list[tgt].flag =
1655 			    MRDRV_TGT_VALID;
1656 			mutex_exit(&instance->config_dev_mtx);
1657 			con_log(CL_ANN1, (CE_NOTE, "mrsas_tran_tgt_init:"
1658 			    "t%xl%x", tgt, lun));
1659 		}
1660 	}
1661 
1662 	return (DDI_SUCCESS);
1663 }
1664 
1665 /*ARGSUSED*/
1666 static void
mrsas_tran_tgt_free(dev_info_t * hba_dip,dev_info_t * tgt_dip,scsi_hba_tran_t * hba_tran,struct scsi_device * sd)1667 mrsas_tran_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
1668     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
1669 {
1670 	struct mrsas_instance *instance;
1671 	int tgt = sd->sd_address.a_target;
1672 	int lun = sd->sd_address.a_lun;
1673 
1674 	instance = ADDR2MR(&sd->sd_address);
1675 
1676 	con_log(CL_DLEVEL2, (CE_NOTE, "tgt_free t = %d l = %d", tgt, lun));
1677 
1678 	if (tgt < MRDRV_MAX_LD && lun == 0) {
1679 		if (instance->mr_ld_list[tgt].dip == tgt_dip) {
1680 			mutex_enter(&instance->config_dev_mtx);
1681 			instance->mr_ld_list[tgt].dip = NULL;
1682 			mutex_exit(&instance->config_dev_mtx);
1683 		}
1684 	} else if (instance->tbolt || instance->skinny) {
1685 		mutex_enter(&instance->config_dev_mtx);
1686 		instance->mr_tbolt_pd_list[tgt].dip = NULL;
1687 		mutex_exit(&instance->config_dev_mtx);
1688 		con_log(CL_ANN1, (CE_NOTE, "tgt_free: Setting dip = NULL"
1689 		    "for tgt:%x", tgt));
1690 	}
1691 }
1692 
1693 dev_info_t *
mrsas_find_child(struct mrsas_instance * instance,uint16_t tgt,uint8_t lun)1694 mrsas_find_child(struct mrsas_instance *instance, uint16_t tgt, uint8_t lun)
1695 {
1696 	dev_info_t *child = NULL;
1697 	char addr[SCSI_MAXNAMELEN];
1698 	char tmp[MAXNAMELEN];
1699 
1700 	(void) snprintf(addr, sizeof (addr), "%x,%x", tgt, lun);
1701 	for (child = ddi_get_child(instance->dip); child;
1702 	    child = ddi_get_next_sibling(child)) {
1703 
1704 		if (ndi_dev_is_persistent_node(child) == 0) {
1705 			continue;
1706 		}
1707 
1708 		if (mrsas_name_node(child, tmp, MAXNAMELEN) !=
1709 		    DDI_SUCCESS) {
1710 			continue;
1711 		}
1712 
1713 		if (strcmp(addr, tmp) == 0) {
1714 			break;
1715 		}
1716 	}
1717 	con_log(CL_DLEVEL2, (CE_NOTE, "mrsas_find_child: return child = %p",
1718 	    (void *)child));
1719 	return (child);
1720 }
1721 
1722 /*
1723  * mrsas_name_node -
1724  * @dip:
1725  * @name:
1726  * @len:
1727  */
1728 static int
mrsas_name_node(dev_info_t * dip,char * name,int len)1729 mrsas_name_node(dev_info_t *dip, char *name, int len)
1730 {
1731 	int tgt, lun;
1732 
1733 	tgt = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
1734 	    DDI_PROP_DONTPASS, "target", -1);
1735 	con_log(CL_DLEVEL2, (CE_NOTE,
1736 	    "mrsas_name_node: dip %p tgt %d", (void *)dip, tgt));
1737 	if (tgt == -1) {
1738 		return (DDI_FAILURE);
1739 	}
1740 	lun = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
1741 	    "lun", -1);
1742 	con_log(CL_DLEVEL2,
1743 	    (CE_NOTE, "mrsas_name_node: tgt %d lun %d", tgt, lun));
1744 	if (lun == -1) {
1745 		return (DDI_FAILURE);
1746 	}
1747 	(void) snprintf(name, len, "%x,%x", tgt, lun);
1748 	return (DDI_SUCCESS);
1749 }
1750 
1751 /*
1752  * tran_init_pkt - allocate & initialize a scsi_pkt structure
1753  * @ap:
1754  * @pkt:
1755  * @bp:
1756  * @cmdlen:
1757  * @statuslen:
1758  * @tgtlen:
1759  * @flags:
1760  * @callback:
1761  *
1762  * The tran_init_pkt() entry point allocates and initializes a scsi_pkt
1763  * structure and DMA resources for a target driver request. The
1764  * tran_init_pkt() entry point is called when the target driver calls the
1765  * SCSA function scsi_init_pkt(). Each call of the tran_init_pkt() entry point
1766  * is a request to perform one or more of three possible services:
1767  *  - allocation and initialization of a scsi_pkt structure
1768  *  - allocation of DMA resources for data transfer
1769  *  - reallocation of DMA resources for the next portion of the data transfer
1770  */
1771 static struct scsi_pkt *
mrsas_tran_init_pkt(struct scsi_address * ap,register struct scsi_pkt * pkt,struct buf * bp,int cmdlen,int statuslen,int tgtlen,int flags,int (* callback)(),caddr_t arg)1772 mrsas_tran_init_pkt(struct scsi_address *ap, register struct scsi_pkt *pkt,
1773     struct buf *bp, int cmdlen, int statuslen, int tgtlen,
1774     int flags, int (*callback)(), caddr_t arg)
1775 {
1776 	struct scsa_cmd	*acmd;
1777 	struct mrsas_instance	*instance;
1778 	struct scsi_pkt	*new_pkt;
1779 
1780 	con_log(CL_DLEVEL1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1781 
1782 	instance = ADDR2MR(ap);
1783 
1784 	/* step #1 : pkt allocation */
1785 	if (pkt == NULL) {
1786 		pkt = scsi_hba_pkt_alloc(instance->dip, ap, cmdlen, statuslen,
1787 		    tgtlen, sizeof (struct scsa_cmd), callback, arg);
1788 		if (pkt == NULL) {
1789 			return (NULL);
1790 		}
1791 
1792 		acmd = PKT2CMD(pkt);
1793 
1794 		/*
1795 		 * Initialize the new pkt - we redundantly initialize
1796 		 * all the fields for illustrative purposes.
1797 		 */
1798 		acmd->cmd_pkt		= pkt;
1799 		acmd->cmd_flags		= 0;
1800 		acmd->cmd_scblen	= statuslen;
1801 		acmd->cmd_cdblen	= cmdlen;
1802 		acmd->cmd_dmahandle	= NULL;
1803 		acmd->cmd_ncookies	= 0;
1804 		acmd->cmd_cookie	= 0;
1805 		acmd->cmd_cookiecnt	= 0;
1806 		acmd->cmd_nwin		= 0;
1807 
1808 		pkt->pkt_address	= *ap;
1809 		pkt->pkt_comp		= (void (*)())NULL;
1810 		pkt->pkt_flags		= 0;
1811 		pkt->pkt_time		= 0;
1812 		pkt->pkt_resid		= 0;
1813 		pkt->pkt_state		= 0;
1814 		pkt->pkt_statistics	= 0;
1815 		pkt->pkt_reason		= 0;
1816 		new_pkt			= pkt;
1817 	} else {
1818 		acmd = PKT2CMD(pkt);
1819 		new_pkt = NULL;
1820 	}
1821 
1822 	/* step #2 : dma allocation/move */
1823 	if (bp && bp->b_bcount != 0) {
1824 		if (acmd->cmd_dmahandle == NULL) {
1825 			if (mrsas_dma_alloc(instance, pkt, bp, flags,
1826 			    callback) == DDI_FAILURE) {
1827 				if (new_pkt) {
1828 					scsi_hba_pkt_free(ap, new_pkt);
1829 				}
1830 				return ((struct scsi_pkt *)NULL);
1831 			}
1832 		} else {
1833 			if (mrsas_dma_move(instance, pkt, bp) == DDI_FAILURE) {
1834 				return ((struct scsi_pkt *)NULL);
1835 			}
1836 		}
1837 	}
1838 
1839 	return (pkt);
1840 }
1841 
1842 /*
1843  * tran_start - transport a SCSI command to the addressed target
1844  * @ap:
1845  * @pkt:
1846  *
1847  * The tran_start() entry point for a SCSI HBA driver is called to transport a
1848  * SCSI command to the addressed target. The SCSI command is described
1849  * entirely within the scsi_pkt structure, which the target driver allocated
1850  * through the HBA driver's tran_init_pkt() entry point. If the command
1851  * involves a data transfer, DMA resources must also have been allocated for
1852  * the scsi_pkt structure.
1853  *
1854  * Return Values :
1855  *	TRAN_BUSY - request queue is full, no more free scbs
1856  *	TRAN_ACCEPT - pkt has been submitted to the instance
1857  */
1858 static int
mrsas_tran_start(struct scsi_address * ap,register struct scsi_pkt * pkt)1859 mrsas_tran_start(struct scsi_address *ap, register struct scsi_pkt *pkt)
1860 {
1861 	uchar_t		cmd_done = 0;
1862 
1863 	struct mrsas_instance	*instance = ADDR2MR(ap);
1864 	struct mrsas_cmd	*cmd;
1865 
1866 	con_log(CL_DLEVEL1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1867 	if (instance->deadadapter == 1) {
1868 		con_log(CL_ANN1, (CE_WARN,
1869 		    "mrsas_tran_start: return TRAN_FATAL_ERROR "
1870 		    "for IO, as the HBA doesnt take any more IOs"));
1871 		if (pkt) {
1872 			pkt->pkt_reason		= CMD_DEV_GONE;
1873 			pkt->pkt_statistics	= STAT_DISCON;
1874 		}
1875 		return (TRAN_FATAL_ERROR);
1876 	}
1877 
1878 	if (instance->adapterresetinprogress) {
1879 		con_log(CL_ANN1, (CE_NOTE, "mrsas_tran_start: Reset flag set, "
1880 		    "returning mfi_pkt and setting TRAN_BUSY\n"));
1881 		return (TRAN_BUSY);
1882 	}
1883 
1884 	con_log(CL_ANN1, (CE_CONT, "chkpnt:%s:%d:SCSI CDB[0]=0x%x time:%x",
1885 	    __func__, __LINE__, pkt->pkt_cdbp[0], pkt->pkt_time));
1886 
1887 	pkt->pkt_reason	= CMD_CMPLT;
1888 	*pkt->pkt_scbp = STATUS_GOOD; /* clear arq scsi_status */
1889 
1890 	cmd = build_cmd(instance, ap, pkt, &cmd_done);
1891 
1892 	/*
1893 	 * Check if the command is already completed by the mrsas_build_cmd()
1894 	 * routine. In which case the busy_flag would be clear and scb will be
1895 	 * NULL and appropriate reason provided in pkt_reason field
1896 	 */
1897 	if (cmd_done) {
1898 		pkt->pkt_reason = CMD_CMPLT;
1899 		pkt->pkt_scbp[0] = STATUS_GOOD;
1900 		pkt->pkt_state |= STATE_GOT_BUS | STATE_GOT_TARGET
1901 		    | STATE_SENT_CMD;
1902 		if (((pkt->pkt_flags & FLAG_NOINTR) == 0) && pkt->pkt_comp) {
1903 			(*pkt->pkt_comp)(pkt);
1904 		}
1905 
1906 		return (TRAN_ACCEPT);
1907 	}
1908 
1909 	if (cmd == NULL) {
1910 		return (TRAN_BUSY);
1911 	}
1912 
1913 	if ((pkt->pkt_flags & FLAG_NOINTR) == 0) {
1914 		if (instance->fw_outstanding > instance->max_fw_cmds) {
1915 			con_log(CL_ANN, (CE_CONT, "mr_sas:Firmware busy"));
1916 			DTRACE_PROBE2(start_tran_err,
1917 			    uint16_t, instance->fw_outstanding,
1918 			    uint16_t, instance->max_fw_cmds);
1919 			mrsas_return_mfi_pkt(instance, cmd);
1920 			return (TRAN_BUSY);
1921 		}
1922 
1923 		/* Synchronize the Cmd frame for the controller */
1924 		(void) ddi_dma_sync(cmd->frame_dma_obj.dma_handle, 0, 0,
1925 		    DDI_DMA_SYNC_FORDEV);
1926 		con_log(CL_ANN, (CE_CONT, "issue_cmd_ppc: SCSI CDB[0]=0x%x"
1927 		    "cmd->index:%x\n", pkt->pkt_cdbp[0], cmd->index));
1928 		instance->func_ptr->issue_cmd(cmd, instance);
1929 
1930 	} else {
1931 		struct mrsas_header *hdr = &cmd->frame->hdr;
1932 
1933 		instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd);
1934 
1935 		pkt->pkt_reason		= CMD_CMPLT;
1936 		pkt->pkt_statistics	= 0;
1937 		pkt->pkt_state |= STATE_XFERRED_DATA | STATE_GOT_STATUS;
1938 
1939 		switch (ddi_get8(cmd->frame_dma_obj.acc_handle,
1940 		    &hdr->cmd_status)) {
1941 		case MFI_STAT_OK:
1942 			pkt->pkt_scbp[0] = STATUS_GOOD;
1943 			break;
1944 
1945 		case MFI_STAT_SCSI_DONE_WITH_ERROR:
1946 			con_log(CL_ANN, (CE_CONT,
1947 			    "mrsas_tran_start: scsi done with error"));
1948 			pkt->pkt_reason	= CMD_CMPLT;
1949 			pkt->pkt_statistics = 0;
1950 
1951 			((struct scsi_status *)pkt->pkt_scbp)->sts_chk = 1;
1952 			break;
1953 
1954 		case MFI_STAT_DEVICE_NOT_FOUND:
1955 			con_log(CL_ANN, (CE_CONT,
1956 			    "mrsas_tran_start: device not found error"));
1957 			pkt->pkt_reason		= CMD_DEV_GONE;
1958 			pkt->pkt_statistics	= STAT_DISCON;
1959 			break;
1960 
1961 		default:
1962 			((struct scsi_status *)pkt->pkt_scbp)->sts_busy = 1;
1963 		}
1964 
1965 		(void) mrsas_common_check(instance, cmd);
1966 		DTRACE_PROBE2(start_nointr_done, uint8_t, hdr->cmd,
1967 		    uint8_t, hdr->cmd_status);
1968 		mrsas_return_mfi_pkt(instance, cmd);
1969 
1970 		if (pkt->pkt_comp) {
1971 			(*pkt->pkt_comp)(pkt);
1972 		}
1973 
1974 	}
1975 
1976 	return (TRAN_ACCEPT);
1977 }
1978 
1979 /*
1980  * tran_abort - Abort any commands that are currently in transport
1981  * @ap:
1982  * @pkt:
1983  *
1984  * The tran_abort() entry point for a SCSI HBA driver is called to abort any
1985  * commands that are currently in transport for a particular target. This entry
1986  * point is called when a target driver calls scsi_abort(). The tran_abort()
1987  * entry point should attempt to abort the command denoted by the pkt
1988  * parameter. If the pkt parameter is NULL, tran_abort() should attempt to
1989  * abort all outstanding commands in the transport layer for the particular
1990  * target or logical unit.
1991  */
1992 /*ARGSUSED*/
1993 static int
mrsas_tran_abort(struct scsi_address * ap,struct scsi_pkt * pkt)1994 mrsas_tran_abort(struct scsi_address *ap, struct scsi_pkt *pkt)
1995 {
1996 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1997 
1998 	/* abort command not supported by H/W */
1999 
2000 	return (DDI_FAILURE);
2001 }
2002 
2003 /*
2004  * tran_reset - reset either the SCSI bus or target
2005  * @ap:
2006  * @level:
2007  *
2008  * The tran_reset() entry point for a SCSI HBA driver is called to reset either
2009  * the SCSI bus or a particular SCSI target device. This entry point is called
2010  * when a target driver calls scsi_reset(). The tran_reset() entry point must
2011  * reset the SCSI bus if level is RESET_ALL. If level is RESET_TARGET, just the
2012  * particular target or logical unit must be reset.
2013  */
2014 /*ARGSUSED*/
2015 static int
mrsas_tran_reset(struct scsi_address * ap,int level)2016 mrsas_tran_reset(struct scsi_address *ap, int level)
2017 {
2018 	struct mrsas_instance *instance = ADDR2MR(ap);
2019 
2020 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2021 
2022 	if (wait_for_outstanding(instance)) {
2023 		con_log(CL_ANN1,
2024 		    (CE_CONT, "wait_for_outstanding: return FAIL.\n"));
2025 		return (DDI_FAILURE);
2026 	} else {
2027 		return (DDI_SUCCESS);
2028 	}
2029 }
2030 
2031 /*
2032  * tran_getcap - get one of a set of SCSA-defined capabilities
2033  * @ap:
2034  * @cap:
2035  * @whom:
2036  *
2037  * The target driver can request the current setting of the capability for a
2038  * particular target by setting the whom parameter to nonzero. A whom value of
2039  * zero indicates a request for the current setting of the general capability
2040  * for the SCSI bus or for adapter hardware. The tran_getcap() should return -1
2041  * for undefined capabilities or the current value of the requested capability.
2042  */
2043 /*ARGSUSED*/
2044 static int
mrsas_tran_getcap(struct scsi_address * ap,char * cap,int whom)2045 mrsas_tran_getcap(struct scsi_address *ap, char *cap, int whom)
2046 {
2047 	int	rval = 0;
2048 
2049 	struct mrsas_instance	*instance = ADDR2MR(ap);
2050 
2051 	con_log(CL_DLEVEL2, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2052 
2053 	/* we do allow inquiring about capabilities for other targets */
2054 	if (cap == NULL) {
2055 		return (-1);
2056 	}
2057 
2058 	switch (scsi_hba_lookup_capstr(cap)) {
2059 	case SCSI_CAP_DMA_MAX:
2060 		if (instance->tbolt) {
2061 			/* Limit to 256k max transfer */
2062 			rval = mrsas_tbolt_max_cap_maxxfer;
2063 		} else {
2064 			/* Limit to 16MB max transfer */
2065 			rval = mrsas_max_cap_maxxfer;
2066 		}
2067 		break;
2068 	case SCSI_CAP_MSG_OUT:
2069 		rval = 1;
2070 		break;
2071 	case SCSI_CAP_DISCONNECT:
2072 		rval = 0;
2073 		break;
2074 	case SCSI_CAP_SYNCHRONOUS:
2075 		rval = 0;
2076 		break;
2077 	case SCSI_CAP_WIDE_XFER:
2078 		rval = 1;
2079 		break;
2080 	case SCSI_CAP_TAGGED_QING:
2081 		rval = 1;
2082 		break;
2083 	case SCSI_CAP_UNTAGGED_QING:
2084 		rval = 1;
2085 		break;
2086 	case SCSI_CAP_PARITY:
2087 		rval = 1;
2088 		break;
2089 	case SCSI_CAP_INITIATOR_ID:
2090 		rval = instance->init_id;
2091 		break;
2092 	case SCSI_CAP_ARQ:
2093 		rval = 1;
2094 		break;
2095 	case SCSI_CAP_LINKED_CMDS:
2096 		rval = 0;
2097 		break;
2098 	case SCSI_CAP_RESET_NOTIFICATION:
2099 		rval = 1;
2100 		break;
2101 	case SCSI_CAP_GEOMETRY:
2102 		rval = -1;
2103 
2104 		break;
2105 	default:
2106 		con_log(CL_DLEVEL2, (CE_NOTE, "Default cap coming 0x%x",
2107 		    scsi_hba_lookup_capstr(cap)));
2108 		rval = -1;
2109 		break;
2110 	}
2111 
2112 	return (rval);
2113 }
2114 
2115 /*
2116  * tran_setcap - set one of a set of SCSA-defined capabilities
2117  * @ap:
2118  * @cap:
2119  * @value:
2120  * @whom:
2121  *
2122  * The target driver might request that the new value be set for a particular
2123  * target by setting the whom parameter to nonzero. A whom value of zero
2124  * means that request is to set the new value for the SCSI bus or for adapter
2125  * hardware in general.
2126  * The tran_setcap() should return the following values as appropriate:
2127  * - -1 for undefined capabilities
2128  * - 0 if the HBA driver cannot set the capability to the requested value
2129  * - 1 if the HBA driver is able to set the capability to the requested value
2130  */
2131 /*ARGSUSED*/
2132 static int
mrsas_tran_setcap(struct scsi_address * ap,char * cap,int value,int whom)2133 mrsas_tran_setcap(struct scsi_address *ap, char *cap, int value, int whom)
2134 {
2135 	int		rval = 1;
2136 
2137 	con_log(CL_DLEVEL2, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2138 
2139 	/* We don't allow setting capabilities for other targets */
2140 	if (cap == NULL || whom == 0) {
2141 		return (-1);
2142 	}
2143 
2144 	switch (scsi_hba_lookup_capstr(cap)) {
2145 		case SCSI_CAP_DMA_MAX:
2146 		case SCSI_CAP_MSG_OUT:
2147 		case SCSI_CAP_PARITY:
2148 		case SCSI_CAP_LINKED_CMDS:
2149 		case SCSI_CAP_RESET_NOTIFICATION:
2150 		case SCSI_CAP_DISCONNECT:
2151 		case SCSI_CAP_SYNCHRONOUS:
2152 		case SCSI_CAP_UNTAGGED_QING:
2153 		case SCSI_CAP_WIDE_XFER:
2154 		case SCSI_CAP_INITIATOR_ID:
2155 		case SCSI_CAP_ARQ:
2156 			/*
2157 			 * None of these are settable via
2158 			 * the capability interface.
2159 			 */
2160 			break;
2161 		case SCSI_CAP_TAGGED_QING:
2162 			rval = 1;
2163 			break;
2164 		case SCSI_CAP_SECTOR_SIZE:
2165 			rval = 1;
2166 			break;
2167 
2168 		case SCSI_CAP_TOTAL_SECTORS:
2169 			rval = 1;
2170 			break;
2171 		default:
2172 			rval = -1;
2173 			break;
2174 	}
2175 
2176 	return (rval);
2177 }
2178 
2179 /*
2180  * tran_destroy_pkt - deallocate scsi_pkt structure
2181  * @ap:
2182  * @pkt:
2183  *
2184  * The tran_destroy_pkt() entry point is the HBA driver function that
2185  * deallocates scsi_pkt structures. The tran_destroy_pkt() entry point is
2186  * called when the target driver calls scsi_destroy_pkt(). The
2187  * tran_destroy_pkt() entry point must free any DMA resources that have been
2188  * allocated for the packet. An implicit DMA synchronization occurs if the
2189  * DMA resources are freed and any cached data remains after the completion
2190  * of the transfer.
2191  */
2192 static void
mrsas_tran_destroy_pkt(struct scsi_address * ap,struct scsi_pkt * pkt)2193 mrsas_tran_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
2194 {
2195 	struct scsa_cmd *acmd = PKT2CMD(pkt);
2196 
2197 	con_log(CL_DLEVEL2, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2198 
2199 	if (acmd->cmd_flags & CFLAG_DMAVALID) {
2200 		acmd->cmd_flags &= ~CFLAG_DMAVALID;
2201 
2202 		(void) ddi_dma_unbind_handle(acmd->cmd_dmahandle);
2203 
2204 		ddi_dma_free_handle(&acmd->cmd_dmahandle);
2205 
2206 		acmd->cmd_dmahandle = NULL;
2207 	}
2208 
2209 	/* free the pkt */
2210 	scsi_hba_pkt_free(ap, pkt);
2211 }
2212 
2213 /*
2214  * tran_dmafree - deallocates DMA resources
2215  * @ap:
2216  * @pkt:
2217  *
2218  * The tran_dmafree() entry point deallocates DMAQ resources that have been
2219  * allocated for a scsi_pkt structure. The tran_dmafree() entry point is
2220  * called when the target driver calls scsi_dmafree(). The tran_dmafree() must
2221  * free only DMA resources allocated for a scsi_pkt structure, not the
2222  * scsi_pkt itself. When DMA resources are freed, a DMA synchronization is
2223  * implicitly performed.
2224  */
2225 /*ARGSUSED*/
2226 static void
mrsas_tran_dmafree(struct scsi_address * ap,struct scsi_pkt * pkt)2227 mrsas_tran_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
2228 {
2229 	register struct scsa_cmd *acmd = PKT2CMD(pkt);
2230 
2231 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2232 
2233 	if (acmd->cmd_flags & CFLAG_DMAVALID) {
2234 		acmd->cmd_flags &= ~CFLAG_DMAVALID;
2235 
2236 		(void) ddi_dma_unbind_handle(acmd->cmd_dmahandle);
2237 
2238 		ddi_dma_free_handle(&acmd->cmd_dmahandle);
2239 
2240 		acmd->cmd_dmahandle = NULL;
2241 	}
2242 }
2243 
2244 /*
2245  * tran_sync_pkt - synchronize the DMA object allocated
2246  * @ap:
2247  * @pkt:
2248  *
2249  * The tran_sync_pkt() entry point synchronizes the DMA object allocated for
2250  * the scsi_pkt structure before or after a DMA transfer. The tran_sync_pkt()
2251  * entry point is called when the target driver calls scsi_sync_pkt(). If the
2252  * data transfer direction is a DMA read from device to memory, tran_sync_pkt()
2253  * must synchronize the CPU's view of the data. If the data transfer direction
2254  * is a DMA write from memory to device, tran_sync_pkt() must synchronize the
2255  * device's view of the data.
2256  */
2257 /*ARGSUSED*/
2258 static void
mrsas_tran_sync_pkt(struct scsi_address * ap,struct scsi_pkt * pkt)2259 mrsas_tran_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
2260 {
2261 	register struct scsa_cmd	*acmd = PKT2CMD(pkt);
2262 
2263 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2264 
2265 	if (acmd->cmd_flags & CFLAG_DMAVALID) {
2266 		(void) ddi_dma_sync(acmd->cmd_dmahandle, acmd->cmd_dma_offset,
2267 		    acmd->cmd_dma_len, (acmd->cmd_flags & CFLAG_DMASEND) ?
2268 		    DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU);
2269 	}
2270 }
2271 
2272 /*ARGSUSED*/
2273 static int
mrsas_tran_quiesce(dev_info_t * dip)2274 mrsas_tran_quiesce(dev_info_t *dip)
2275 {
2276 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2277 
2278 	return (1);
2279 }
2280 
2281 /*ARGSUSED*/
2282 static int
mrsas_tran_unquiesce(dev_info_t * dip)2283 mrsas_tran_unquiesce(dev_info_t *dip)
2284 {
2285 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2286 
2287 	return (1);
2288 }
2289 
2290 
2291 /*
2292  * mrsas_isr(caddr_t, caddr_t)
2293  *
2294  * The Interrupt Service Routine
2295  *
2296  * Collect status for all completed commands and do callback
2297  *
2298  */
2299 static uint_t
mrsas_isr(caddr_t arg1,caddr_t arg2 __unused)2300 mrsas_isr(caddr_t arg1, caddr_t arg2 __unused)
2301 {
2302 	struct mrsas_instance *instance = (struct mrsas_instance *)arg1;
2303 	int		need_softintr;
2304 	uint32_t	producer;
2305 	uint32_t	consumer;
2306 	uint32_t	context;
2307 	int		retval;
2308 
2309 	struct mrsas_cmd	*cmd;
2310 	struct mrsas_header	*hdr;
2311 	struct scsi_pkt		*pkt;
2312 
2313 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2314 	ASSERT(instance);
2315 	if (instance->tbolt) {
2316 		mutex_enter(&instance->chip_mtx);
2317 		if ((instance->intr_type == DDI_INTR_TYPE_FIXED) &&
2318 		    !(instance->func_ptr->intr_ack(instance))) {
2319 			mutex_exit(&instance->chip_mtx);
2320 			return (DDI_INTR_UNCLAIMED);
2321 		}
2322 		retval = mr_sas_tbolt_process_outstanding_cmd(instance);
2323 		mutex_exit(&instance->chip_mtx);
2324 		return (retval);
2325 	} else {
2326 		if ((instance->intr_type == DDI_INTR_TYPE_FIXED) &&
2327 		    !instance->func_ptr->intr_ack(instance)) {
2328 			return (DDI_INTR_UNCLAIMED);
2329 		}
2330 	}
2331 
2332 	(void) ddi_dma_sync(instance->mfi_internal_dma_obj.dma_handle,
2333 	    0, 0, DDI_DMA_SYNC_FORCPU);
2334 
2335 	if (mrsas_check_dma_handle(instance->mfi_internal_dma_obj.dma_handle)
2336 	    != DDI_SUCCESS) {
2337 		mrsas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
2338 		ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
2339 		con_log(CL_ANN1, (CE_WARN,
2340 		    "mr_sas_isr(): FMA check, returning DDI_INTR_UNCLAIMED"));
2341 		return (DDI_INTR_CLAIMED);
2342 	}
2343 	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2344 
2345 #ifdef OCRDEBUG
2346 	if (debug_consecutive_timeout_after_ocr_g == 1) {
2347 		con_log(CL_ANN1, (CE_NOTE,
2348 		    "simulating consecutive timeout after ocr"));
2349 		return (DDI_INTR_CLAIMED);
2350 	}
2351 #endif
2352 
2353 	mutex_enter(&instance->completed_pool_mtx);
2354 	mutex_enter(&instance->cmd_pend_mtx);
2355 
2356 	producer = ddi_get32(instance->mfi_internal_dma_obj.acc_handle,
2357 	    instance->producer);
2358 	consumer = ddi_get32(instance->mfi_internal_dma_obj.acc_handle,
2359 	    instance->consumer);
2360 
2361 	con_log(CL_ANN, (CE_CONT, " producer %x consumer %x ",
2362 	    producer, consumer));
2363 	if (producer == consumer) {
2364 		con_log(CL_ANN, (CE_WARN, "producer ==	consumer case"));
2365 		DTRACE_PROBE2(isr_pc_err, uint32_t, producer,
2366 		    uint32_t, consumer);
2367 		mutex_exit(&instance->cmd_pend_mtx);
2368 		mutex_exit(&instance->completed_pool_mtx);
2369 		return (DDI_INTR_CLAIMED);
2370 	}
2371 
2372 	while (consumer != producer) {
2373 		context = ddi_get32(instance->mfi_internal_dma_obj.acc_handle,
2374 		    &instance->reply_queue[consumer]);
2375 		cmd = instance->cmd_list[context];
2376 
2377 		if (cmd->sync_cmd == MRSAS_TRUE) {
2378 			hdr = (struct mrsas_header *)&cmd->frame->hdr;
2379 			if (hdr) {
2380 				mlist_del_init(&cmd->list);
2381 			}
2382 		} else {
2383 			pkt = cmd->pkt;
2384 			if (pkt) {
2385 				mlist_del_init(&cmd->list);
2386 			}
2387 		}
2388 
2389 		mlist_add_tail(&cmd->list, &instance->completed_pool_list);
2390 
2391 		consumer++;
2392 		if (consumer == (instance->max_fw_cmds + 1)) {
2393 			consumer = 0;
2394 		}
2395 	}
2396 	ddi_put32(instance->mfi_internal_dma_obj.acc_handle,
2397 	    instance->consumer, consumer);
2398 	mutex_exit(&instance->cmd_pend_mtx);
2399 	mutex_exit(&instance->completed_pool_mtx);
2400 
2401 	(void) ddi_dma_sync(instance->mfi_internal_dma_obj.dma_handle,
2402 	    0, 0, DDI_DMA_SYNC_FORDEV);
2403 
2404 	if (instance->softint_running) {
2405 		need_softintr = 0;
2406 	} else {
2407 		need_softintr = 1;
2408 	}
2409 
2410 	if (instance->isr_level == HIGH_LEVEL_INTR) {
2411 		if (need_softintr) {
2412 			ddi_trigger_softintr(instance->soft_intr_id);
2413 		}
2414 	} else {
2415 		/*
2416 		 * Not a high-level interrupt, therefore call the soft level
2417 		 * interrupt explicitly
2418 		 */
2419 		(void) mrsas_softintr(instance);
2420 	}
2421 
2422 	return (DDI_INTR_CLAIMED);
2423 }
2424 
2425 
2426 /*
2427  * ************************************************************************** *
2428  *									      *
2429  *				    libraries				      *
2430  *									      *
2431  * ************************************************************************** *
2432  */
2433 /*
2434  * get_mfi_pkt : Get a command from the free pool
2435  * After successful allocation, the caller of this routine
2436  * must clear the frame buffer (memset to zero) before
2437  * using the packet further.
2438  *
2439  * ***** Note *****
2440  * After clearing the frame buffer the context id of the
2441  * frame buffer SHOULD be restored back.
2442  */
2443 struct mrsas_cmd *
mrsas_get_mfi_pkt(struct mrsas_instance * instance)2444 mrsas_get_mfi_pkt(struct mrsas_instance *instance)
2445 {
2446 	mlist_t			*head = &instance->cmd_pool_list;
2447 	struct mrsas_cmd	*cmd = NULL;
2448 
2449 	mutex_enter(&instance->cmd_pool_mtx);
2450 
2451 	if (!mlist_empty(head)) {
2452 		cmd = mlist_entry(head->next, struct mrsas_cmd, list);
2453 		mlist_del_init(head->next);
2454 	}
2455 	if (cmd != NULL) {
2456 		cmd->pkt = NULL;
2457 		cmd->retry_count_for_ocr = 0;
2458 		cmd->drv_pkt_time = 0;
2459 
2460 	}
2461 	mutex_exit(&instance->cmd_pool_mtx);
2462 
2463 	return (cmd);
2464 }
2465 
2466 static struct mrsas_cmd *
get_mfi_app_pkt(struct mrsas_instance * instance)2467 get_mfi_app_pkt(struct mrsas_instance *instance)
2468 {
2469 	mlist_t				*head = &instance->app_cmd_pool_list;
2470 	struct mrsas_cmd	*cmd = NULL;
2471 
2472 	mutex_enter(&instance->app_cmd_pool_mtx);
2473 
2474 	if (!mlist_empty(head)) {
2475 		cmd = mlist_entry(head->next, struct mrsas_cmd, list);
2476 		mlist_del_init(head->next);
2477 	}
2478 	if (cmd != NULL) {
2479 		cmd->pkt = NULL;
2480 		cmd->retry_count_for_ocr = 0;
2481 		cmd->drv_pkt_time = 0;
2482 	}
2483 
2484 	mutex_exit(&instance->app_cmd_pool_mtx);
2485 
2486 	return (cmd);
2487 }
2488 /*
2489  * return_mfi_pkt : Return a cmd to free command pool
2490  */
2491 void
mrsas_return_mfi_pkt(struct mrsas_instance * instance,struct mrsas_cmd * cmd)2492 mrsas_return_mfi_pkt(struct mrsas_instance *instance, struct mrsas_cmd *cmd)
2493 {
2494 	mutex_enter(&instance->cmd_pool_mtx);
2495 	/* use mlist_add_tail for debug assistance */
2496 	mlist_add_tail(&cmd->list, &instance->cmd_pool_list);
2497 
2498 	mutex_exit(&instance->cmd_pool_mtx);
2499 }
2500 
2501 static void
return_mfi_app_pkt(struct mrsas_instance * instance,struct mrsas_cmd * cmd)2502 return_mfi_app_pkt(struct mrsas_instance *instance, struct mrsas_cmd *cmd)
2503 {
2504 	mutex_enter(&instance->app_cmd_pool_mtx);
2505 
2506 	mlist_add(&cmd->list, &instance->app_cmd_pool_list);
2507 
2508 	mutex_exit(&instance->app_cmd_pool_mtx);
2509 }
2510 void
push_pending_mfi_pkt(struct mrsas_instance * instance,struct mrsas_cmd * cmd)2511 push_pending_mfi_pkt(struct mrsas_instance *instance, struct mrsas_cmd *cmd)
2512 {
2513 	struct scsi_pkt *pkt;
2514 	struct mrsas_header	*hdr;
2515 	con_log(CL_DLEVEL2, (CE_NOTE, "push_pending_pkt(): Called\n"));
2516 	mutex_enter(&instance->cmd_pend_mtx);
2517 	mlist_del_init(&cmd->list);
2518 	mlist_add_tail(&cmd->list, &instance->cmd_pend_list);
2519 	if (cmd->sync_cmd == MRSAS_TRUE) {
2520 		hdr = (struct mrsas_header *)&cmd->frame->hdr;
2521 		if (hdr) {
2522 			con_log(CL_ANN1, (CE_CONT,
2523 			    "push_pending_mfi_pkt: "
2524 			    "cmd %p index %x "
2525 			    "time %llx",
2526 			    (void *)cmd, cmd->index,
2527 			    gethrtime()));
2528 			/* Wait for specified interval	*/
2529 			cmd->drv_pkt_time = ddi_get16(
2530 			    cmd->frame_dma_obj.acc_handle, &hdr->timeout);
2531 			if (cmd->drv_pkt_time < debug_timeout_g)
2532 				cmd->drv_pkt_time = (uint16_t)debug_timeout_g;
2533 				con_log(CL_ANN1, (CE_CONT,
2534 				    "push_pending_pkt(): "
2535 				    "Called IO Timeout Value %x\n",
2536 				    cmd->drv_pkt_time));
2537 		}
2538 		if (hdr && instance->timeout_id == (timeout_id_t)-1) {
2539 			instance->timeout_id = timeout(io_timeout_checker,
2540 			    (void *) instance, drv_usectohz(MRSAS_1_SECOND));
2541 		}
2542 	} else {
2543 		pkt = cmd->pkt;
2544 		if (pkt) {
2545 			con_log(CL_ANN1, (CE_CONT,
2546 			    "push_pending_mfi_pkt: "
2547 			    "cmd %p index %x pkt %p, "
2548 			    "time %llx",
2549 			    (void *)cmd, cmd->index, (void *)pkt,
2550 			    gethrtime()));
2551 			cmd->drv_pkt_time = (uint16_t)debug_timeout_g;
2552 		}
2553 		if (pkt && instance->timeout_id == (timeout_id_t)-1) {
2554 			instance->timeout_id = timeout(io_timeout_checker,
2555 			    (void *) instance, drv_usectohz(MRSAS_1_SECOND));
2556 		}
2557 	}
2558 
2559 	mutex_exit(&instance->cmd_pend_mtx);
2560 
2561 }
2562 
2563 int
mrsas_print_pending_cmds(struct mrsas_instance * instance)2564 mrsas_print_pending_cmds(struct mrsas_instance *instance)
2565 {
2566 	mlist_t *head = &instance->cmd_pend_list;
2567 	mlist_t *tmp = head;
2568 	struct mrsas_cmd *cmd = NULL;
2569 	struct mrsas_header	*hdr;
2570 	unsigned int		flag = 1;
2571 	struct scsi_pkt *pkt;
2572 	int saved_level;
2573 	int cmd_count = 0;
2574 
2575 	saved_level = debug_level_g;
2576 	debug_level_g = CL_ANN1;
2577 
2578 	dev_err(instance->dip, CE_NOTE,
2579 	    "mrsas_print_pending_cmds(): Called");
2580 
2581 	while (flag) {
2582 		mutex_enter(&instance->cmd_pend_mtx);
2583 		tmp	=	tmp->next;
2584 		if (tmp == head) {
2585 			mutex_exit(&instance->cmd_pend_mtx);
2586 			flag = 0;
2587 			con_log(CL_ANN1, (CE_CONT, "mrsas_print_pending_cmds():"
2588 			    " NO MORE CMDS PENDING....\n"));
2589 			break;
2590 		} else {
2591 			cmd = mlist_entry(tmp, struct mrsas_cmd, list);
2592 			mutex_exit(&instance->cmd_pend_mtx);
2593 			if (cmd) {
2594 				if (cmd->sync_cmd == MRSAS_TRUE) {
2595 					hdr = (struct mrsas_header *)
2596 					    &cmd->frame->hdr;
2597 					if (hdr) {
2598 						con_log(CL_ANN1, (CE_CONT,
2599 						    "print: cmd %p index 0x%x "
2600 						    "drv_pkt_time 0x%x (NO-PKT)"
2601 						    " hdr %p\n", (void *)cmd,
2602 						    cmd->index,
2603 						    cmd->drv_pkt_time,
2604 						    (void *)hdr));
2605 					}
2606 				} else {
2607 					pkt = cmd->pkt;
2608 					if (pkt) {
2609 					con_log(CL_ANN1, (CE_CONT,
2610 					    "print: cmd %p index 0x%x "
2611 					    "drv_pkt_time 0x%x pkt %p \n",
2612 					    (void *)cmd, cmd->index,
2613 					    cmd->drv_pkt_time, (void *)pkt));
2614 					}
2615 				}
2616 
2617 				if (++cmd_count == 1) {
2618 					mrsas_print_cmd_details(instance, cmd,
2619 					    0xDD);
2620 				} else {
2621 					mrsas_print_cmd_details(instance, cmd,
2622 					    1);
2623 				}
2624 
2625 			}
2626 		}
2627 	}
2628 	con_log(CL_ANN1, (CE_CONT, "mrsas_print_pending_cmds(): Done\n"));
2629 
2630 
2631 	debug_level_g = saved_level;
2632 
2633 	return (DDI_SUCCESS);
2634 }
2635 
2636 
2637 int
mrsas_complete_pending_cmds(struct mrsas_instance * instance)2638 mrsas_complete_pending_cmds(struct mrsas_instance *instance)
2639 {
2640 
2641 	struct mrsas_cmd *cmd = NULL;
2642 	struct scsi_pkt *pkt;
2643 	struct mrsas_header *hdr;
2644 
2645 	struct mlist_head		*pos, *next;
2646 
2647 	con_log(CL_ANN1, (CE_NOTE,
2648 	    "mrsas_complete_pending_cmds(): Called"));
2649 
2650 	mutex_enter(&instance->cmd_pend_mtx);
2651 	mlist_for_each_safe(pos, next, &instance->cmd_pend_list) {
2652 		cmd = mlist_entry(pos, struct mrsas_cmd, list);
2653 		if (cmd) {
2654 			pkt = cmd->pkt;
2655 			if (pkt) { /* for IO */
2656 				if (((pkt->pkt_flags & FLAG_NOINTR)
2657 				    == 0) && pkt->pkt_comp) {
2658 					pkt->pkt_reason
2659 					    = CMD_DEV_GONE;
2660 					pkt->pkt_statistics
2661 					    = STAT_DISCON;
2662 					con_log(CL_ANN1, (CE_CONT,
2663 					    "fail and posting to scsa "
2664 					    "cmd %p index %x"
2665 					    " pkt %p "
2666 					    "time : %llx",
2667 					    (void *)cmd, cmd->index,
2668 					    (void *)pkt, gethrtime()));
2669 					(*pkt->pkt_comp)(pkt);
2670 				}
2671 			} else { /* for DCMDS */
2672 				if (cmd->sync_cmd == MRSAS_TRUE) {
2673 				hdr = (struct mrsas_header *)&cmd->frame->hdr;
2674 				con_log(CL_ANN1, (CE_CONT,
2675 				    "posting invalid status to application "
2676 				    "cmd %p index %x"
2677 				    " hdr %p "
2678 				    "time : %llx",
2679 				    (void *)cmd, cmd->index,
2680 				    (void *)hdr, gethrtime()));
2681 				hdr->cmd_status = MFI_STAT_INVALID_STATUS;
2682 				complete_cmd_in_sync_mode(instance, cmd);
2683 				}
2684 			}
2685 			mlist_del_init(&cmd->list);
2686 		} else {
2687 			con_log(CL_ANN1, (CE_CONT,
2688 			    "mrsas_complete_pending_cmds:"
2689 			    "NULL command\n"));
2690 		}
2691 		con_log(CL_ANN1, (CE_CONT,
2692 		    "mrsas_complete_pending_cmds:"
2693 		    "looping for more commands\n"));
2694 	}
2695 	mutex_exit(&instance->cmd_pend_mtx);
2696 
2697 	con_log(CL_ANN1, (CE_CONT, "mrsas_complete_pending_cmds(): DONE\n"));
2698 	return (DDI_SUCCESS);
2699 }
2700 
2701 void
mrsas_print_cmd_details(struct mrsas_instance * instance,struct mrsas_cmd * cmd,int detail)2702 mrsas_print_cmd_details(struct mrsas_instance *instance, struct mrsas_cmd *cmd,
2703     int detail)
2704 {
2705 	struct scsi_pkt *pkt = cmd->pkt;
2706 	Mpi2RaidSCSIIORequest_t *scsi_io = cmd->scsi_io_request;
2707 	int i;
2708 	int saved_level;
2709 	ddi_acc_handle_t acc_handle =
2710 	    instance->mpi2_frame_pool_dma_obj.acc_handle;
2711 
2712 	if (detail == 0xDD) {
2713 		saved_level = debug_level_g;
2714 		debug_level_g = CL_ANN1;
2715 	}
2716 
2717 
2718 	if (instance->tbolt) {
2719 		con_log(CL_ANN1, (CE_CONT, "print_cmd_details: cmd %p "
2720 		    "cmd->index 0x%x SMID 0x%x timer 0x%x sec\n",
2721 		    (void *)cmd, cmd->index, cmd->SMID, cmd->drv_pkt_time));
2722 	} else {
2723 		con_log(CL_ANN1, (CE_CONT, "print_cmd_details: cmd %p "
2724 		    "cmd->index 0x%x timer 0x%x sec\n",
2725 		    (void *)cmd, cmd->index, cmd->drv_pkt_time));
2726 	}
2727 
2728 	if (pkt) {
2729 		con_log(CL_ANN1, (CE_CONT, "scsi_pkt CDB[0]=0x%x",
2730 		    pkt->pkt_cdbp[0]));
2731 	} else {
2732 		con_log(CL_ANN1, (CE_CONT, "NO-PKT"));
2733 	}
2734 
2735 	if ((detail == 0xDD) && instance->tbolt) {
2736 		con_log(CL_ANN1, (CE_CONT, "RAID_SCSI_IO_REQUEST\n"));
2737 		con_log(CL_ANN1, (CE_CONT, "DevHandle=0x%X Function=0x%X "
2738 		    "IoFlags=0x%X SGLFlags=0x%X DataLength=0x%X\n",
2739 		    ddi_get16(acc_handle, &scsi_io->DevHandle),
2740 		    ddi_get8(acc_handle, &scsi_io->Function),
2741 		    ddi_get16(acc_handle, &scsi_io->IoFlags),
2742 		    ddi_get16(acc_handle, &scsi_io->SGLFlags),
2743 		    ddi_get32(acc_handle, &scsi_io->DataLength)));
2744 
2745 		for (i = 0; i < 32; i++) {
2746 			con_log(CL_ANN1, (CE_CONT, "CDB[%d]=0x%x ", i,
2747 			    ddi_get8(acc_handle, &scsi_io->CDB.CDB32[i])));
2748 		}
2749 
2750 		con_log(CL_ANN1, (CE_CONT, "RAID-CONTEXT\n"));
2751 		con_log(CL_ANN1, (CE_CONT, "status=0x%X extStatus=0x%X "
2752 		    "ldTargetId=0x%X timeoutValue=0x%X regLockFlags=0x%X "
2753 		    "RAIDFlags=0x%X regLockRowLBA=0x%" PRIu64
2754 		    " regLockLength=0x%X spanArm=0x%X\n",
2755 		    ddi_get8(acc_handle, &scsi_io->RaidContext.status),
2756 		    ddi_get8(acc_handle, &scsi_io->RaidContext.extStatus),
2757 		    ddi_get16(acc_handle, &scsi_io->RaidContext.ldTargetId),
2758 		    ddi_get16(acc_handle, &scsi_io->RaidContext.timeoutValue),
2759 		    ddi_get8(acc_handle, &scsi_io->RaidContext.regLockFlags),
2760 		    ddi_get8(acc_handle, &scsi_io->RaidContext.RAIDFlags),
2761 		    ddi_get64(acc_handle, &scsi_io->RaidContext.regLockRowLBA),
2762 		    ddi_get32(acc_handle, &scsi_io->RaidContext.regLockLength),
2763 		    ddi_get8(acc_handle, &scsi_io->RaidContext.spanArm)));
2764 	}
2765 
2766 	if (detail == 0xDD) {
2767 		debug_level_g = saved_level;
2768 	}
2769 }
2770 
2771 
2772 int
mrsas_issue_pending_cmds(struct mrsas_instance * instance)2773 mrsas_issue_pending_cmds(struct mrsas_instance *instance)
2774 {
2775 	mlist_t *head	=	&instance->cmd_pend_list;
2776 	mlist_t *tmp	=	head->next;
2777 	struct mrsas_cmd *cmd = NULL;
2778 	struct scsi_pkt *pkt;
2779 
2780 	con_log(CL_ANN1, (CE_NOTE, "mrsas_issue_pending_cmds(): Called"));
2781 	while (tmp != head) {
2782 		mutex_enter(&instance->cmd_pend_mtx);
2783 		cmd = mlist_entry(tmp, struct mrsas_cmd, list);
2784 		tmp = tmp->next;
2785 		mutex_exit(&instance->cmd_pend_mtx);
2786 		if (cmd) {
2787 			con_log(CL_ANN1, (CE_CONT,
2788 			    "mrsas_issue_pending_cmds(): "
2789 			    "Got a cmd: cmd %p index 0x%x drv_pkt_time 0x%x ",
2790 			    (void *)cmd, cmd->index, cmd->drv_pkt_time));
2791 
2792 			/* Reset command timeout value */
2793 			if (cmd->drv_pkt_time < debug_timeout_g)
2794 				cmd->drv_pkt_time = (uint16_t)debug_timeout_g;
2795 
2796 			cmd->retry_count_for_ocr++;
2797 
2798 			dev_err(instance->dip, CE_CONT,
2799 			    "cmd retry count = %d\n",
2800 			    cmd->retry_count_for_ocr);
2801 
2802 			if (cmd->retry_count_for_ocr > IO_RETRY_COUNT) {
2803 				dev_err(instance->dip,
2804 				    CE_WARN, "mrsas_issue_pending_cmds(): "
2805 				    "cmd->retry_count exceeded limit >%d\n",
2806 				    IO_RETRY_COUNT);
2807 				mrsas_print_cmd_details(instance, cmd, 0xDD);
2808 
2809 				dev_err(instance->dip, CE_WARN,
2810 				    "mrsas_issue_pending_cmds():"
2811 				    "Calling KILL Adapter");
2812 				if (instance->tbolt)
2813 					mrsas_tbolt_kill_adapter(instance);
2814 				else
2815 					(void) mrsas_kill_adapter(instance);
2816 				return (DDI_FAILURE);
2817 			}
2818 
2819 			pkt = cmd->pkt;
2820 			if (pkt) {
2821 				con_log(CL_ANN1, (CE_CONT,
2822 				    "PENDING PKT-CMD ISSUE: cmd %p index %x "
2823 				    "pkt %p time %llx",
2824 				    (void *)cmd, cmd->index,
2825 				    (void *)pkt,
2826 				    gethrtime()));
2827 
2828 			} else {
2829 				dev_err(instance->dip, CE_CONT,
2830 				    "mrsas_issue_pending_cmds(): NO-PKT, "
2831 				    "cmd %p index 0x%x drv_pkt_time 0x%x",
2832 				    (void *)cmd, cmd->index, cmd->drv_pkt_time);
2833 			}
2834 
2835 
2836 			if (cmd->sync_cmd == MRSAS_TRUE) {
2837 				dev_err(instance->dip, CE_CONT,
2838 				    "mrsas_issue_pending_cmds(): "
2839 				    "SYNC_CMD == TRUE \n");
2840 				instance->func_ptr->issue_cmd_in_sync_mode(
2841 				    instance, cmd);
2842 			} else {
2843 				instance->func_ptr->issue_cmd(cmd, instance);
2844 			}
2845 		} else {
2846 			con_log(CL_ANN1, (CE_CONT,
2847 			    "mrsas_issue_pending_cmds: NULL command\n"));
2848 		}
2849 		con_log(CL_ANN1, (CE_CONT,
2850 		    "mrsas_issue_pending_cmds:"
2851 		    "looping for more commands"));
2852 	}
2853 	con_log(CL_ANN1, (CE_CONT, "mrsas_issue_pending_cmds(): DONE\n"));
2854 	return (DDI_SUCCESS);
2855 }
2856 
2857 
2858 
2859 /*
2860  * destroy_mfi_frame_pool
2861  */
2862 void
destroy_mfi_frame_pool(struct mrsas_instance * instance)2863 destroy_mfi_frame_pool(struct mrsas_instance *instance)
2864 {
2865 	int		i;
2866 	uint32_t	max_cmd = instance->max_fw_cmds;
2867 
2868 	struct mrsas_cmd	*cmd;
2869 
2870 	/* return all frames to pool */
2871 
2872 	for (i = 0; i < max_cmd; i++) {
2873 
2874 		cmd = instance->cmd_list[i];
2875 
2876 		if (cmd->frame_dma_obj_status == DMA_OBJ_ALLOCATED)
2877 			(void) mrsas_free_dma_obj(instance, cmd->frame_dma_obj);
2878 
2879 		cmd->frame_dma_obj_status  = DMA_OBJ_FREED;
2880 	}
2881 
2882 }
2883 
2884 /*
2885  * create_mfi_frame_pool
2886  */
2887 int
create_mfi_frame_pool(struct mrsas_instance * instance)2888 create_mfi_frame_pool(struct mrsas_instance *instance)
2889 {
2890 	int		i = 0;
2891 	int		cookie_cnt;
2892 	uint16_t	max_cmd;
2893 	uint16_t	sge_sz;
2894 	uint32_t	sgl_sz;
2895 	uint32_t	tot_frame_size;
2896 	struct mrsas_cmd	*cmd;
2897 	int			retval = DDI_SUCCESS;
2898 
2899 	max_cmd = instance->max_fw_cmds;
2900 	sge_sz	= sizeof (struct mrsas_sge_ieee);
2901 	/* calculated the number of 64byte frames required for SGL */
2902 	sgl_sz		= sge_sz * instance->max_num_sge;
2903 	tot_frame_size	= sgl_sz + MRMFI_FRAME_SIZE + SENSE_LENGTH;
2904 
2905 	con_log(CL_DLEVEL3, (CE_NOTE, "create_mfi_frame_pool: "
2906 	    "sgl_sz %x tot_frame_size %x", sgl_sz, tot_frame_size));
2907 
2908 	while (i < max_cmd) {
2909 		cmd = instance->cmd_list[i];
2910 
2911 		cmd->frame_dma_obj.size	= tot_frame_size;
2912 		cmd->frame_dma_obj.dma_attr = mrsas_generic_dma_attr;
2913 		cmd->frame_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
2914 		cmd->frame_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
2915 		cmd->frame_dma_obj.dma_attr.dma_attr_sgllen = 1;
2916 		cmd->frame_dma_obj.dma_attr.dma_attr_align = 64;
2917 
2918 		cookie_cnt = mrsas_alloc_dma_obj(instance, &cmd->frame_dma_obj,
2919 		    (uchar_t)DDI_STRUCTURE_LE_ACC);
2920 
2921 		if (cookie_cnt == -1 || cookie_cnt > 1) {
2922 			dev_err(instance->dip, CE_WARN,
2923 			    "create_mfi_frame_pool: could not alloc.");
2924 			retval = DDI_FAILURE;
2925 			goto mrsas_undo_frame_pool;
2926 		}
2927 
2928 		bzero(cmd->frame_dma_obj.buffer, tot_frame_size);
2929 
2930 		cmd->frame_dma_obj_status = DMA_OBJ_ALLOCATED;
2931 		cmd->frame = (union mrsas_frame *)cmd->frame_dma_obj.buffer;
2932 		cmd->frame_phys_addr =
2933 		    cmd->frame_dma_obj.dma_cookie[0].dmac_address;
2934 
2935 		cmd->sense = (uint8_t *)(((unsigned long)
2936 		    cmd->frame_dma_obj.buffer) +
2937 		    tot_frame_size - SENSE_LENGTH);
2938 		cmd->sense_phys_addr =
2939 		    cmd->frame_dma_obj.dma_cookie[0].dmac_address +
2940 		    tot_frame_size - SENSE_LENGTH;
2941 
2942 		if (!cmd->frame || !cmd->sense) {
2943 			dev_err(instance->dip, CE_WARN,
2944 			    "pci_pool_alloc failed");
2945 			retval = ENOMEM;
2946 			goto mrsas_undo_frame_pool;
2947 		}
2948 
2949 		ddi_put32(cmd->frame_dma_obj.acc_handle,
2950 		    &cmd->frame->io.context, cmd->index);
2951 		i++;
2952 
2953 		con_log(CL_DLEVEL3, (CE_NOTE, "[%x]-%x",
2954 		    cmd->index, cmd->frame_phys_addr));
2955 	}
2956 
2957 	return (DDI_SUCCESS);
2958 
2959 mrsas_undo_frame_pool:
2960 	if (i > 0)
2961 		destroy_mfi_frame_pool(instance);
2962 
2963 	return (retval);
2964 }
2965 
2966 /*
2967  * free_additional_dma_buffer
2968  */
2969 static void
free_additional_dma_buffer(struct mrsas_instance * instance)2970 free_additional_dma_buffer(struct mrsas_instance *instance)
2971 {
2972 	if (instance->mfi_internal_dma_obj.status == DMA_OBJ_ALLOCATED) {
2973 		(void) mrsas_free_dma_obj(instance,
2974 		    instance->mfi_internal_dma_obj);
2975 		instance->mfi_internal_dma_obj.status = DMA_OBJ_FREED;
2976 	}
2977 
2978 	if (instance->mfi_evt_detail_obj.status == DMA_OBJ_ALLOCATED) {
2979 		(void) mrsas_free_dma_obj(instance,
2980 		    instance->mfi_evt_detail_obj);
2981 		instance->mfi_evt_detail_obj.status = DMA_OBJ_FREED;
2982 	}
2983 }
2984 
2985 /*
2986  * alloc_additional_dma_buffer
2987  */
2988 static int
alloc_additional_dma_buffer(struct mrsas_instance * instance)2989 alloc_additional_dma_buffer(struct mrsas_instance *instance)
2990 {
2991 	uint32_t	reply_q_sz;
2992 	uint32_t	internal_buf_size = PAGESIZE*2;
2993 
2994 	/* max cmds plus 1 + producer & consumer */
2995 	reply_q_sz = sizeof (uint32_t) * (instance->max_fw_cmds + 1 + 2);
2996 
2997 	instance->mfi_internal_dma_obj.size = internal_buf_size;
2998 	instance->mfi_internal_dma_obj.dma_attr	= mrsas_generic_dma_attr;
2999 	instance->mfi_internal_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
3000 	instance->mfi_internal_dma_obj.dma_attr.dma_attr_count_max =
3001 	    0xFFFFFFFFU;
3002 	instance->mfi_internal_dma_obj.dma_attr.dma_attr_sgllen	= 1;
3003 
3004 	if (mrsas_alloc_dma_obj(instance, &instance->mfi_internal_dma_obj,
3005 	    (uchar_t)DDI_STRUCTURE_LE_ACC) != 1) {
3006 		dev_err(instance->dip, CE_WARN,
3007 		    "could not alloc reply queue");
3008 		return (DDI_FAILURE);
3009 	}
3010 
3011 	bzero(instance->mfi_internal_dma_obj.buffer, internal_buf_size);
3012 
3013 	instance->mfi_internal_dma_obj.status |= DMA_OBJ_ALLOCATED;
3014 
3015 	instance->producer = (uint32_t *)((unsigned long)
3016 	    instance->mfi_internal_dma_obj.buffer);
3017 	instance->consumer = (uint32_t *)((unsigned long)
3018 	    instance->mfi_internal_dma_obj.buffer + 4);
3019 	instance->reply_queue = (uint32_t *)((unsigned long)
3020 	    instance->mfi_internal_dma_obj.buffer + 8);
3021 	instance->internal_buf = (caddr_t)(((unsigned long)
3022 	    instance->mfi_internal_dma_obj.buffer) + reply_q_sz + 8);
3023 	instance->internal_buf_dmac_add =
3024 	    instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address +
3025 	    (reply_q_sz + 8);
3026 	instance->internal_buf_size = internal_buf_size -
3027 	    (reply_q_sz + 8);
3028 
3029 	/* allocate evt_detail */
3030 	instance->mfi_evt_detail_obj.size = sizeof (struct mrsas_evt_detail);
3031 	instance->mfi_evt_detail_obj.dma_attr = mrsas_generic_dma_attr;
3032 	instance->mfi_evt_detail_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
3033 	instance->mfi_evt_detail_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
3034 	instance->mfi_evt_detail_obj.dma_attr.dma_attr_sgllen = 1;
3035 	instance->mfi_evt_detail_obj.dma_attr.dma_attr_align = 1;
3036 
3037 	if (mrsas_alloc_dma_obj(instance, &instance->mfi_evt_detail_obj,
3038 	    (uchar_t)DDI_STRUCTURE_LE_ACC) != 1) {
3039 		dev_err(instance->dip, CE_WARN, "alloc_additional_dma_buffer: "
3040 		    "could not allocate data transfer buffer.");
3041 		goto mrsas_undo_internal_buff;
3042 	}
3043 
3044 	bzero(instance->mfi_evt_detail_obj.buffer,
3045 	    sizeof (struct mrsas_evt_detail));
3046 
3047 	instance->mfi_evt_detail_obj.status |= DMA_OBJ_ALLOCATED;
3048 
3049 	return (DDI_SUCCESS);
3050 
3051 mrsas_undo_internal_buff:
3052 	if (instance->mfi_internal_dma_obj.status == DMA_OBJ_ALLOCATED) {
3053 		(void) mrsas_free_dma_obj(instance,
3054 		    instance->mfi_internal_dma_obj);
3055 		instance->mfi_internal_dma_obj.status = DMA_OBJ_FREED;
3056 	}
3057 
3058 	return (DDI_FAILURE);
3059 }
3060 
3061 
3062 void
mrsas_free_cmd_pool(struct mrsas_instance * instance)3063 mrsas_free_cmd_pool(struct mrsas_instance *instance)
3064 {
3065 	int		i;
3066 	uint32_t	max_cmd;
3067 	size_t		sz;
3068 
3069 	/* already freed */
3070 	if (instance->cmd_list == NULL) {
3071 		return;
3072 	}
3073 
3074 	max_cmd = instance->max_fw_cmds;
3075 
3076 	/* size of cmd_list array */
3077 	sz = sizeof (struct mrsas_cmd *) * max_cmd;
3078 
3079 	/* First free each cmd */
3080 	for (i = 0; i < max_cmd; i++) {
3081 		if (instance->cmd_list[i] != NULL) {
3082 			kmem_free(instance->cmd_list[i],
3083 			    sizeof (struct mrsas_cmd));
3084 		}
3085 
3086 		instance->cmd_list[i] = NULL;
3087 	}
3088 
3089 	/* Now, free cmd_list array */
3090 	if (instance->cmd_list != NULL)
3091 		kmem_free(instance->cmd_list, sz);
3092 
3093 	instance->cmd_list = NULL;
3094 
3095 	INIT_LIST_HEAD(&instance->cmd_pool_list);
3096 	INIT_LIST_HEAD(&instance->cmd_pend_list);
3097 	if (instance->tbolt) {
3098 		INIT_LIST_HEAD(&instance->cmd_app_pool_list);
3099 	} else {
3100 		INIT_LIST_HEAD(&instance->app_cmd_pool_list);
3101 	}
3102 
3103 }
3104 
3105 
3106 /*
3107  * mrsas_alloc_cmd_pool
3108  */
3109 int
mrsas_alloc_cmd_pool(struct mrsas_instance * instance)3110 mrsas_alloc_cmd_pool(struct mrsas_instance *instance)
3111 {
3112 	int		i;
3113 	int		count;
3114 	uint32_t	max_cmd;
3115 	uint32_t	reserve_cmd;
3116 	size_t		sz;
3117 
3118 	struct mrsas_cmd	*cmd;
3119 
3120 	max_cmd = instance->max_fw_cmds;
3121 	con_log(CL_ANN1, (CE_NOTE, "mrsas_alloc_cmd_pool: "
3122 	    "max_cmd %x", max_cmd));
3123 
3124 
3125 	sz = sizeof (struct mrsas_cmd *) * max_cmd;
3126 
3127 	/*
3128 	 * instance->cmd_list is an array of struct mrsas_cmd pointers.
3129 	 * Allocate the dynamic array first and then allocate individual
3130 	 * commands.
3131 	 */
3132 	instance->cmd_list = kmem_zalloc(sz, KM_SLEEP);
3133 	ASSERT(instance->cmd_list);
3134 
3135 	/* create a frame pool and assign one frame to each cmd */
3136 	for (count = 0; count < max_cmd; count++) {
3137 		instance->cmd_list[count] =
3138 		    kmem_zalloc(sizeof (struct mrsas_cmd), KM_SLEEP);
3139 		ASSERT(instance->cmd_list[count]);
3140 	}
3141 
3142 	/* add all the commands to command pool */
3143 
3144 	INIT_LIST_HEAD(&instance->cmd_pool_list);
3145 	INIT_LIST_HEAD(&instance->cmd_pend_list);
3146 	INIT_LIST_HEAD(&instance->app_cmd_pool_list);
3147 
3148 	/*
3149 	 * When max_cmd is lower than MRSAS_APP_RESERVED_CMDS, how do I split
3150 	 * into app_cmd and regular cmd?  For now, just take
3151 	 * max(1/8th of max, 4);
3152 	 */
3153 	reserve_cmd = min(MRSAS_APP_RESERVED_CMDS,
3154 	    max(max_cmd >> 3, MRSAS_APP_MIN_RESERVED_CMDS));
3155 
3156 	for (i = 0; i < reserve_cmd; i++) {
3157 		cmd = instance->cmd_list[i];
3158 		cmd->index = i;
3159 		mlist_add_tail(&cmd->list, &instance->app_cmd_pool_list);
3160 	}
3161 
3162 
3163 	for (i = reserve_cmd; i < max_cmd; i++) {
3164 		cmd = instance->cmd_list[i];
3165 		cmd->index = i;
3166 		mlist_add_tail(&cmd->list, &instance->cmd_pool_list);
3167 	}
3168 
3169 	return (DDI_SUCCESS);
3170 
3171 mrsas_undo_cmds:
3172 	if (count > 0) {
3173 		/* free each cmd */
3174 		for (i = 0; i < count; i++) {
3175 			if (instance->cmd_list[i] != NULL) {
3176 				kmem_free(instance->cmd_list[i],
3177 				    sizeof (struct mrsas_cmd));
3178 			}
3179 			instance->cmd_list[i] = NULL;
3180 		}
3181 	}
3182 
3183 mrsas_undo_cmd_list:
3184 	if (instance->cmd_list != NULL)
3185 		kmem_free(instance->cmd_list, sz);
3186 	instance->cmd_list = NULL;
3187 
3188 	return (DDI_FAILURE);
3189 }
3190 
3191 
3192 /*
3193  * free_space_for_mfi
3194  */
3195 static void
free_space_for_mfi(struct mrsas_instance * instance)3196 free_space_for_mfi(struct mrsas_instance *instance)
3197 {
3198 
3199 	/* already freed */
3200 	if (instance->cmd_list == NULL) {
3201 		return;
3202 	}
3203 
3204 	/* Free additional dma buffer */
3205 	free_additional_dma_buffer(instance);
3206 
3207 	/* Free the MFI frame pool */
3208 	destroy_mfi_frame_pool(instance);
3209 
3210 	/* Free all the commands in the cmd_list */
3211 	/* Free the cmd_list buffer itself */
3212 	mrsas_free_cmd_pool(instance);
3213 }
3214 
3215 /*
3216  * alloc_space_for_mfi
3217  */
3218 static int
alloc_space_for_mfi(struct mrsas_instance * instance)3219 alloc_space_for_mfi(struct mrsas_instance *instance)
3220 {
3221 	/* Allocate command pool (memory for cmd_list & individual commands) */
3222 	if (mrsas_alloc_cmd_pool(instance)) {
3223 		dev_err(instance->dip, CE_WARN, "error creating cmd pool");
3224 		return (DDI_FAILURE);
3225 	}
3226 
3227 	/* Allocate MFI Frame pool */
3228 	if (create_mfi_frame_pool(instance)) {
3229 		dev_err(instance->dip, CE_WARN,
3230 		    "error creating frame DMA pool");
3231 		goto mfi_undo_cmd_pool;
3232 	}
3233 
3234 	/* Allocate additional DMA buffer */
3235 	if (alloc_additional_dma_buffer(instance)) {
3236 		dev_err(instance->dip, CE_WARN,
3237 		    "error creating frame DMA pool");
3238 		goto mfi_undo_frame_pool;
3239 	}
3240 
3241 	return (DDI_SUCCESS);
3242 
3243 mfi_undo_frame_pool:
3244 	destroy_mfi_frame_pool(instance);
3245 
3246 mfi_undo_cmd_pool:
3247 	mrsas_free_cmd_pool(instance);
3248 
3249 	return (DDI_FAILURE);
3250 }
3251 
3252 
3253 
3254 /*
3255  * get_ctrl_info
3256  */
3257 static int
get_ctrl_info(struct mrsas_instance * instance,struct mrsas_ctrl_info * ctrl_info)3258 get_ctrl_info(struct mrsas_instance *instance,
3259     struct mrsas_ctrl_info *ctrl_info)
3260 {
3261 	int	ret = 0;
3262 
3263 	struct mrsas_cmd		*cmd;
3264 	struct mrsas_dcmd_frame	*dcmd;
3265 	struct mrsas_ctrl_info	*ci;
3266 
3267 	if (instance->tbolt) {
3268 		cmd = get_raid_msg_mfi_pkt(instance);
3269 	} else {
3270 		cmd = mrsas_get_mfi_pkt(instance);
3271 	}
3272 
3273 	if (!cmd) {
3274 		con_log(CL_ANN, (CE_WARN,
3275 		    "Failed to get a cmd for ctrl info"));
3276 		DTRACE_PROBE2(info_mfi_err, uint16_t, instance->fw_outstanding,
3277 		    uint16_t, instance->max_fw_cmds);
3278 		return (DDI_FAILURE);
3279 	}
3280 
3281 	/* Clear the frame buffer and assign back the context id */
3282 	(void) memset((char *)&cmd->frame[0], 0, sizeof (union mrsas_frame));
3283 	ddi_put32(cmd->frame_dma_obj.acc_handle, &cmd->frame->hdr.context,
3284 	    cmd->index);
3285 
3286 	dcmd = &cmd->frame->dcmd;
3287 
3288 	ci = (struct mrsas_ctrl_info *)instance->internal_buf;
3289 
3290 	if (!ci) {
3291 		dev_err(instance->dip, CE_WARN,
3292 		    "Failed to alloc mem for ctrl info");
3293 		mrsas_return_mfi_pkt(instance, cmd);
3294 		return (DDI_FAILURE);
3295 	}
3296 
3297 	(void) memset(ci, 0, sizeof (struct mrsas_ctrl_info));
3298 
3299 	/* for( i = 0; i < DCMD_MBOX_SZ; i++ ) dcmd->mbox.b[i] = 0; */
3300 	(void) memset(dcmd->mbox.b, 0, DCMD_MBOX_SZ);
3301 
3302 	ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->cmd, MFI_CMD_OP_DCMD);
3303 	ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->cmd_status,
3304 	    MFI_CMD_STATUS_POLL_MODE);
3305 	ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->sge_count, 1);
3306 	ddi_put16(cmd->frame_dma_obj.acc_handle, &dcmd->flags,
3307 	    MFI_FRAME_DIR_READ);
3308 	ddi_put16(cmd->frame_dma_obj.acc_handle, &dcmd->timeout, 0);
3309 	ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->data_xfer_len,
3310 	    sizeof (struct mrsas_ctrl_info));
3311 	ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->opcode,
3312 	    MR_DCMD_CTRL_GET_INFO);
3313 	ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->sgl.sge32[0].phys_addr,
3314 	    instance->internal_buf_dmac_add);
3315 	ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->sgl.sge32[0].length,
3316 	    sizeof (struct mrsas_ctrl_info));
3317 
3318 	cmd->frame_count = 1;
3319 
3320 	if (instance->tbolt) {
3321 		mr_sas_tbolt_build_mfi_cmd(instance, cmd);
3322 	}
3323 
3324 	if (!instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
3325 		ret = 0;
3326 
3327 		ctrl_info->max_request_size = ddi_get32(
3328 		    cmd->frame_dma_obj.acc_handle, &ci->max_request_size);
3329 
3330 		ctrl_info->ld_present_count = ddi_get16(
3331 		    cmd->frame_dma_obj.acc_handle, &ci->ld_present_count);
3332 
3333 		ctrl_info->properties.on_off_properties = ddi_get32(
3334 		    cmd->frame_dma_obj.acc_handle,
3335 		    &ci->properties.on_off_properties);
3336 		ddi_rep_get8(cmd->frame_dma_obj.acc_handle,
3337 		    (uint8_t *)(ctrl_info->product_name),
3338 		    (uint8_t *)(ci->product_name), 80 * sizeof (char),
3339 		    DDI_DEV_AUTOINCR);
3340 		/* should get more members of ci with ddi_get when needed */
3341 	} else {
3342 		dev_err(instance->dip, CE_WARN,
3343 		    "get_ctrl_info: Ctrl info failed");
3344 		ret = -1;
3345 	}
3346 
3347 	if (mrsas_common_check(instance, cmd) != DDI_SUCCESS) {
3348 		ret = -1;
3349 	}
3350 	if (instance->tbolt) {
3351 		return_raid_msg_mfi_pkt(instance, cmd);
3352 	} else {
3353 		mrsas_return_mfi_pkt(instance, cmd);
3354 	}
3355 
3356 	return (ret);
3357 }
3358 
3359 /*
3360  * abort_aen_cmd
3361  */
3362 static int
abort_aen_cmd(struct mrsas_instance * instance,struct mrsas_cmd * cmd_to_abort)3363 abort_aen_cmd(struct mrsas_instance *instance,
3364     struct mrsas_cmd *cmd_to_abort)
3365 {
3366 	int	ret = 0;
3367 
3368 	struct mrsas_cmd		*cmd;
3369 	struct mrsas_abort_frame	*abort_fr;
3370 
3371 	con_log(CL_ANN1, (CE_NOTE, "chkpnt: abort_aen:%d", __LINE__));
3372 
3373 	if (instance->tbolt) {
3374 		cmd = get_raid_msg_mfi_pkt(instance);
3375 	} else {
3376 		cmd = mrsas_get_mfi_pkt(instance);
3377 	}
3378 
3379 	if (!cmd) {
3380 		con_log(CL_ANN1, (CE_WARN,
3381 		    "abort_aen_cmd():Failed to get a cmd for abort_aen_cmd"));
3382 		DTRACE_PROBE2(abort_mfi_err, uint16_t, instance->fw_outstanding,
3383 		    uint16_t, instance->max_fw_cmds);
3384 		return (DDI_FAILURE);
3385 	}
3386 
3387 	/* Clear the frame buffer and assign back the context id */
3388 	(void) memset((char *)&cmd->frame[0], 0, sizeof (union mrsas_frame));
3389 	ddi_put32(cmd->frame_dma_obj.acc_handle, &cmd->frame->hdr.context,
3390 	    cmd->index);
3391 
3392 	abort_fr = &cmd->frame->abort;
3393 
3394 	/* prepare and issue the abort frame */
3395 	ddi_put8(cmd->frame_dma_obj.acc_handle,
3396 	    &abort_fr->cmd, MFI_CMD_OP_ABORT);
3397 	ddi_put8(cmd->frame_dma_obj.acc_handle, &abort_fr->cmd_status,
3398 	    MFI_CMD_STATUS_SYNC_MODE);
3399 	ddi_put16(cmd->frame_dma_obj.acc_handle, &abort_fr->flags, 0);
3400 	ddi_put32(cmd->frame_dma_obj.acc_handle, &abort_fr->abort_context,
3401 	    cmd_to_abort->index);
3402 	ddi_put32(cmd->frame_dma_obj.acc_handle,
3403 	    &abort_fr->abort_mfi_phys_addr_lo, cmd_to_abort->frame_phys_addr);
3404 	ddi_put32(cmd->frame_dma_obj.acc_handle,
3405 	    &abort_fr->abort_mfi_phys_addr_hi, 0);
3406 
3407 	instance->aen_cmd->abort_aen = 1;
3408 
3409 	cmd->frame_count = 1;
3410 
3411 	if (instance->tbolt) {
3412 		mr_sas_tbolt_build_mfi_cmd(instance, cmd);
3413 	}
3414 
3415 	if (instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
3416 		con_log(CL_ANN1, (CE_WARN,
3417 		    "abort_aen_cmd: issue_cmd_in_poll_mode failed"));
3418