xref: /illumos-gate/usr/src/uts/common/io/aac/aac_ioctl.c (revision 89b42a211fa7d3527b9615260f495d22e430c5c5)
1 /*
2  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
3  */
4 
5 /*
6  * Copyright 2005-06 Adaptec, Inc.
7  * Copyright (c) 2005-06 Adaptec Inc., Achim Leubner
8  * Copyright (c) 2000 Michael Smith
9  * Copyright (c) 2001 Scott Long
10  * Copyright (c) 2000 BSDi
11  * All rights reserved.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34 #include <sys/modctl.h>
35 #include <sys/conf.h>
36 #include <sys/cmn_err.h>
37 #include <sys/ddi.h>
38 #include <sys/devops.h>
39 #include <sys/pci.h>
40 #include <sys/types.h>
41 #include <sys/ddidmareq.h>
42 #include <sys/scsi/scsi.h>
43 #include <sys/ksynch.h>
44 #include <sys/sunddi.h>
45 #include <sys/byteorder.h>
46 #include <sys/kmem.h>
47 #include "aac_regs.h"
48 #include "aac.h"
49 #include "aac_ioctl.h"
50 
51 struct aac_umem_sge {
52 	uint32_t bcount;
53 	caddr_t addr;
54 	struct aac_cmd acp;
55 };
56 
57 /*
58  * External functions
59  */
60 extern int aac_sync_mbcommand(struct aac_softstate *, uint32_t, uint32_t,
61     uint32_t, uint32_t, uint32_t, uint32_t *);
62 extern int aac_cmd_dma_alloc(struct aac_softstate *, struct aac_cmd *,
63     struct buf *, int, int (*)(), caddr_t);
64 extern void aac_free_dmamap(struct aac_cmd *);
65 extern int aac_do_io(struct aac_softstate *, struct aac_cmd *);
66 extern void aac_cmd_fib_copy(struct aac_softstate *, struct aac_cmd *);
67 extern void aac_ioctl_complete(struct aac_softstate *, struct aac_cmd *);
68 extern int aac_return_aif_wait(struct aac_softstate *, struct aac_fib_context *,
69     struct aac_fib **);
70 extern int aac_return_aif(struct aac_softstate *, struct aac_fib_context *,
71     struct aac_fib **);
72 
73 extern ddi_device_acc_attr_t aac_acc_attr;
74 extern int aac_check_dma_handle(ddi_dma_handle_t);
75 
76 /*
77  * IOCTL command handling functions
78  */
79 static int aac_check_revision(struct aac_softstate *, intptr_t, int);
80 static int aac_ioctl_send_fib(struct aac_softstate *, intptr_t, int);
81 static int aac_open_getadapter_fib(struct aac_softstate *, intptr_t, int);
82 static int aac_next_getadapter_fib(struct aac_softstate *, intptr_t, int);
83 static int aac_close_getadapter_fib(struct aac_softstate *, intptr_t);
84 static int aac_send_raw_srb(struct aac_softstate *, dev_t, intptr_t, int);
85 static int aac_get_pci_info(struct aac_softstate *, intptr_t, int);
86 static int aac_query_disk(struct aac_softstate *, intptr_t, int);
87 static int aac_delete_disk(struct aac_softstate *, intptr_t, int);
88 static int aac_supported_features(struct aac_softstate *, intptr_t, int);
89 
90 /*
91  * Warlock directives
92  */
93 _NOTE(SCHEME_PROTECTS_DATA("unique to each handling function", aac_features
94     aac_pci_info aac_query_disk aac_revision aac_umem_sge))
95 
96 int
97 aac_do_ioctl(struct aac_softstate *softs, dev_t dev, int cmd, intptr_t arg,
98     int mode)
99 {
100 	int status;
101 
102 	switch (cmd) {
103 	case FSACTL_MINIPORT_REV_CHECK:
104 		AACDB_PRINT_IOCTL(softs, "FSACTL_MINIPORT_REV_CHECK");
105 		status = aac_check_revision(softs, arg, mode);
106 		break;
107 	case FSACTL_SENDFIB:
108 		AACDB_PRINT_IOCTL(softs, "FSACTL_SEND_LARGE_FIB");
109 		goto send_fib;
110 	case FSACTL_SEND_LARGE_FIB:
111 		AACDB_PRINT_IOCTL(softs, "FSACTL_SEND_LARGE_FIB");
112 send_fib:
113 		status = aac_ioctl_send_fib(softs, arg, mode);
114 		break;
115 	case FSACTL_OPEN_GET_ADAPTER_FIB:
116 		AACDB_PRINT_IOCTL(softs, "FSACTL_OPEN_GET_ADAPTER_FIB");
117 		status = aac_open_getadapter_fib(softs, arg, mode);
118 		break;
119 	case FSACTL_GET_NEXT_ADAPTER_FIB:
120 		AACDB_PRINT_IOCTL(softs, "FSACTL_GET_NEXT_ADAPTER_FIB");
121 		status = aac_next_getadapter_fib(softs, arg, mode);
122 		break;
123 	case FSACTL_CLOSE_GET_ADAPTER_FIB:
124 		AACDB_PRINT_IOCTL(softs, "FSACTL_CLOSE_GET_ADAPTER_FIB");
125 		status = aac_close_getadapter_fib(softs, arg);
126 		break;
127 	case FSACTL_SEND_RAW_SRB:
128 		AACDB_PRINT_IOCTL(softs, "FSACTL_SEND_RAW_SRB");
129 		status = aac_send_raw_srb(softs, dev, arg, mode);
130 		break;
131 	case FSACTL_GET_PCI_INFO:
132 		AACDB_PRINT_IOCTL(softs, "FSACTL_GET_PCI_INFO");
133 		status = aac_get_pci_info(softs, arg, mode);
134 		break;
135 	case FSACTL_QUERY_DISK:
136 		AACDB_PRINT_IOCTL(softs, "FSACTL_QUERY_DISK");
137 		status = aac_query_disk(softs, arg, mode);
138 		break;
139 	case FSACTL_DELETE_DISK:
140 		AACDB_PRINT_IOCTL(softs, "FSACTL_DELETE_DISK");
141 		status = aac_delete_disk(softs, arg, mode);
142 		break;
143 	case FSACTL_GET_FEATURES:
144 		AACDB_PRINT_IOCTL(softs, "FSACTL_GET_FEATURES");
145 		status = aac_supported_features(softs, arg, mode);
146 		break;
147 	default:
148 		status = ENOTTY;
149 		AACDB_PRINT(softs, CE_WARN,
150 		    "!IOCTL cmd 0x%x not supported", cmd);
151 		break;
152 	}
153 
154 	return (status);
155 }
156 
157 /*ARGSUSED*/
158 static int
159 aac_check_revision(struct aac_softstate *softs, intptr_t arg, int mode)
160 {
161 	union aac_revision_align un;
162 	struct aac_revision *aac_rev = &un.d;
163 
164 	DBCALLED(softs, 2);
165 
166 	/* Copyin the revision struct from userspace */
167 	if (ddi_copyin((void *)arg, aac_rev,
168 	    sizeof (struct aac_revision), mode) != 0)
169 		return (EFAULT);
170 
171 	/* Doctor up the response struct */
172 	aac_rev->compat = 1;
173 	aac_rev->version =
174 	    ((uint32_t)AAC_DRIVER_MAJOR_VERSION << 24) |
175 	    ((uint32_t)AAC_DRIVER_MINOR_VERSION << 16) |
176 	    ((uint32_t)AAC_DRIVER_TYPE << 8) |
177 	    ((uint32_t)AAC_DRIVER_BUGFIX_LEVEL);
178 	aac_rev->build = (uint32_t)AAC_DRIVER_BUILD;
179 
180 	if (ddi_copyout(aac_rev, (void *)arg,
181 	    sizeof (struct aac_revision), mode) != 0)
182 		return (EFAULT);
183 
184 	return (0);
185 }
186 
187 static int
188 aac_send_fib(struct aac_softstate *softs, struct aac_cmd *acp)
189 {
190 	int rval;
191 
192 	acp->flags |= AAC_CMD_NO_CB | AAC_CMD_SYNC;
193 	acp->ac_comp = aac_ioctl_complete;
194 
195 	mutex_enter(&softs->io_lock);
196 	if (softs->state & AAC_STATE_DEAD) {
197 		mutex_exit(&softs->io_lock);
198 		return (ENXIO);
199 	}
200 
201 	rval = aac_do_io(softs, acp);
202 	if (rval == TRAN_ACCEPT) {
203 		rval = 0;
204 	} else if (rval == TRAN_BADPKT) {
205 		AACDB_PRINT(softs, CE_CONT, "User SendFib failed ENXIO");
206 		rval = ENXIO;
207 	} else if (rval == TRAN_BUSY) {
208 		AACDB_PRINT(softs, CE_CONT, "User SendFib failed EBUSY");
209 		rval = EBUSY;
210 	}
211 	mutex_exit(&softs->io_lock);
212 
213 	return (rval);
214 }
215 
216 static int
217 aac_ioctl_send_fib(struct aac_softstate *softs, intptr_t arg, int mode)
218 {
219 	int hbalen;
220 	struct aac_cmd *acp;
221 	struct aac_fib *fibp;
222 	uint16_t fib_command;
223 	uint32_t fib_xfer_state;
224 	uint16_t fib_data_size, fib_size;
225 	uint16_t fib_sender_size;
226 	int rval;
227 
228 	DBCALLED(softs, 2);
229 
230 	/* Copy in FIB header */
231 	hbalen = sizeof (struct aac_cmd) + softs->aac_max_fib_size;
232 	if ((acp = kmem_zalloc(hbalen, KM_NOSLEEP)) == NULL)
233 		return (ENOMEM);
234 
235 	fibp = (struct aac_fib *)(acp + 1);
236 	acp->fibp = fibp;
237 	if (ddi_copyin((void *)arg, fibp,
238 	    sizeof (struct aac_fib_header), mode) != 0) {
239 		rval = EFAULT;
240 		goto finish;
241 	}
242 
243 	fib_xfer_state = LE_32(fibp->Header.XferState);
244 	fib_command = LE_16(fibp->Header.Command);
245 	fib_data_size = LE_16(fibp->Header.Size);
246 	fib_sender_size = LE_16(fibp->Header.SenderSize);
247 
248 	fib_size = fib_data_size + sizeof (struct aac_fib_header);
249 	if (fib_size < fib_sender_size)
250 		fib_size = fib_sender_size;
251 	if (fib_size > softs->aac_max_fib_size) {
252 		rval = EFAULT;
253 		goto finish;
254 	}
255 
256 	/* Copy in FIB data */
257 	if (ddi_copyin(((struct aac_fib *)arg)->data, fibp->data,
258 	    fib_data_size, mode) != 0) {
259 		rval = EFAULT;
260 		goto finish;
261 	}
262 	acp->fib_size = fib_size;
263 	fibp->Header.Size = LE_16(fib_size);
264 
265 	/* Process FIB */
266 	if (fib_command == TakeABreakPt) {
267 #ifdef DEBUG
268 		if (aac_dbflag_on(softs, AACDB_FLAGS_FIB) &&
269 		    (softs->debug_fib_flags & AACDB_FLAGS_FIB_IOCTL))
270 			aac_printf(softs, CE_NOTE, "FIB> TakeABreakPt, sz=%d",
271 			    fib_size);
272 #endif
273 		(void) aac_sync_mbcommand(softs, AAC_BREAKPOINT_REQ,
274 		    0, 0, 0, 0, NULL);
275 		fibp->Header.XferState = LE_32(0);
276 	} else {
277 		ASSERT(!(fib_xfer_state & AAC_FIBSTATE_ASYNC));
278 		fibp->Header.XferState = LE_32(fib_xfer_state | \
279 		    (AAC_FIBSTATE_FROMHOST | AAC_FIBSTATE_REXPECTED));
280 
281 		acp->timeout = AAC_IOCTL_TIMEOUT;
282 		acp->aac_cmd_fib = aac_cmd_fib_copy;
283 #ifdef DEBUG
284 		acp->fib_flags = AACDB_FLAGS_FIB_IOCTL;
285 #endif
286 		if ((rval = aac_send_fib(softs, acp)) != 0)
287 			goto finish;
288 	}
289 
290 	if (acp->flags & AAC_CMD_ERR) {
291 		AACDB_PRINT(softs, CE_CONT, "FIB data corrupt");
292 		rval = EIO;
293 		goto finish;
294 	}
295 
296 	if (ddi_copyout(fibp, (void *)arg, acp->fib_size, mode) != 0) {
297 		AACDB_PRINT(softs, CE_CONT, "FIB copyout failed");
298 		rval = EFAULT;
299 		goto finish;
300 	}
301 
302 	rval = 0;
303 finish:
304 	kmem_free(acp, hbalen);
305 	return (rval);
306 }
307 
308 static int
309 aac_open_getadapter_fib(struct aac_softstate *softs, intptr_t arg, int mode)
310 {
311 	struct aac_fib_context *fibctx_p, *ctx_p;
312 
313 	DBCALLED(softs, 2);
314 
315 	fibctx_p = kmem_zalloc(sizeof (struct aac_fib_context), KM_NOSLEEP);
316 	if (fibctx_p == NULL)
317 		return (ENOMEM);
318 
319 	mutex_enter(&softs->aifq_mutex);
320 	/* All elements are already 0, add to queue */
321 	if (softs->fibctx_p == NULL) {
322 		softs->fibctx_p = fibctx_p;
323 	} else {
324 		for (ctx_p = softs->fibctx_p; ctx_p->next; ctx_p = ctx_p->next)
325 			;
326 		ctx_p->next = fibctx_p;
327 		fibctx_p->prev = ctx_p;
328 	}
329 
330 	/* Evaluate unique value */
331 	fibctx_p->unique = (unsigned long)fibctx_p & 0xfffffffful;
332 	ctx_p = softs->fibctx_p;
333 	while (ctx_p != fibctx_p) {
334 		if (ctx_p->unique == fibctx_p->unique) {
335 			fibctx_p->unique++;
336 			ctx_p = softs->fibctx_p;
337 		} else {
338 			ctx_p = ctx_p->next;
339 		}
340 	}
341 
342 	/* Set ctx_idx to the oldest AIF */
343 	if (softs->aifq_wrap) {
344 		fibctx_p->ctx_idx = softs->aifq_idx;
345 		fibctx_p->ctx_filled = 1;
346 	}
347 	mutex_exit(&softs->aifq_mutex);
348 
349 	if (ddi_copyout(&fibctx_p->unique, (void *)arg,
350 	    sizeof (uint32_t), mode) != 0)
351 		return (EFAULT);
352 
353 	return (0);
354 }
355 
356 static int
357 aac_next_getadapter_fib(struct aac_softstate *softs, intptr_t arg, int mode)
358 {
359 	union aac_get_adapter_fib_align un;
360 	struct aac_get_adapter_fib *af = &un.d;
361 	struct aac_fib_context *ctx_p;
362 	struct aac_fib *fibp;
363 	int rval;
364 
365 	DBCALLED(softs, 2);
366 
367 	if (ddi_copyin((void *)arg, af, sizeof (*af), mode) != 0)
368 		return (EFAULT);
369 
370 	mutex_enter(&softs->aifq_mutex);
371 	for (ctx_p = softs->fibctx_p; ctx_p; ctx_p = ctx_p->next) {
372 		if (af->context == ctx_p->unique)
373 			break;
374 	}
375 	mutex_exit(&softs->aifq_mutex);
376 
377 	if (ctx_p) {
378 		if (af->wait)
379 			rval = aac_return_aif_wait(softs, ctx_p, &fibp);
380 		else
381 			rval = aac_return_aif(softs, ctx_p, &fibp);
382 	}
383 	else
384 		rval = EFAULT;
385 
386 finish:
387 	if (rval == 0) {
388 		if (ddi_copyout(fibp,
389 #ifdef _LP64
390 		    (void *)(uint64_t)af->aif_fib,
391 #else
392 		    (void *)af->aif_fib,
393 #endif
394 		    sizeof (struct aac_fib), mode) != 0)
395 			rval = EFAULT;
396 	}
397 	return (rval);
398 }
399 
400 static int
401 aac_close_getadapter_fib(struct aac_softstate *softs, intptr_t arg)
402 {
403 	struct aac_fib_context *ctx_p;
404 
405 	DBCALLED(softs, 2);
406 
407 	mutex_enter(&softs->aifq_mutex);
408 	for (ctx_p = softs->fibctx_p; ctx_p; ctx_p = ctx_p->next) {
409 		if (ctx_p->unique != (uint32_t)arg)
410 			continue;
411 
412 		if (ctx_p == softs->fibctx_p)
413 			softs->fibctx_p = ctx_p->next;
414 		else
415 			ctx_p->prev->next = ctx_p->next;
416 		if (ctx_p->next)
417 			ctx_p->next->prev = ctx_p->prev;
418 		break;
419 	}
420 	mutex_exit(&softs->aifq_mutex);
421 	if (ctx_p)
422 		kmem_free(ctx_p, sizeof (struct aac_fib_context));
423 
424 	return (0);
425 }
426 
427 /*
428  * The following function comes from Adaptec:
429  *
430  * SRB is required for the new management tools
431  * Note: SRB passed down from IOCTL is always in CPU endianness.
432  */
433 static int
434 aac_send_raw_srb(struct aac_softstate *softs, dev_t dev, intptr_t arg, int mode)
435 {
436 	struct aac_cmd *acp;
437 	struct aac_fib *fibp;
438 	struct aac_srb *srb;
439 	uint32_t usr_fib_size;
440 	uint32_t srb_sgcount;
441 	struct aac_umem_sge *usgt = NULL;
442 	struct aac_umem_sge *usge;
443 	ddi_umem_cookie_t cookie;
444 	int umem_flags = 0;
445 	int direct = 0;
446 	int locked = 0;
447 	caddr_t addrlo = (caddr_t)-1;
448 	caddr_t addrhi = 0;
449 	struct aac_sge *sge, *sge0;
450 	int sg64;
451 	int rval;
452 
453 	DBCALLED(softs, 2);
454 
455 	/* Read srb size */
456 	if (ddi_copyin(&((struct aac_srb *)arg)->count, &usr_fib_size,
457 	    sizeof (uint32_t), mode) != 0)
458 		return (EFAULT);
459 	if (usr_fib_size > (softs->aac_max_fib_size - \
460 	    sizeof (struct aac_fib_header)))
461 		return (EINVAL);
462 
463 	if ((acp = kmem_zalloc(sizeof (struct aac_cmd) + usr_fib_size + \
464 	    sizeof (struct aac_fib_header), KM_NOSLEEP)) == NULL)
465 		return (ENOMEM);
466 
467 	acp->fibp = (struct aac_fib *)(acp + 1);
468 	fibp = acp->fibp;
469 	srb = (struct aac_srb *)fibp->data;
470 
471 	/* Copy in srb */
472 	if (ddi_copyin((void *)arg, srb, usr_fib_size, mode) != 0) {
473 		rval = EFAULT;
474 		goto finish;
475 	}
476 
477 	srb_sgcount = srb->sg.SgCount; /* No endianness conversion needed */
478 	if (srb_sgcount == 0)
479 		goto send_fib;
480 
481 	/* Check FIB size */
482 	if (usr_fib_size == (sizeof (struct aac_srb) + \
483 	    srb_sgcount * sizeof (struct aac_sg_entry64) - \
484 	    sizeof (struct aac_sg_entry))) {
485 		sg64 = 1;
486 	} else if (usr_fib_size == (sizeof (struct aac_srb) + \
487 	    (srb_sgcount - 1) * sizeof (struct aac_sg_entry))) {
488 		sg64 = 0;
489 	} else {
490 		rval = EINVAL;
491 		goto finish;
492 	}
493 
494 	/* Read user SG table */
495 	if ((usgt = kmem_zalloc(sizeof (struct aac_umem_sge) * srb_sgcount,
496 	    KM_NOSLEEP)) == NULL) {
497 		rval = ENOMEM;
498 		goto finish;
499 	}
500 	for (usge = usgt; usge < &usgt[srb_sgcount]; usge++) {
501 		if (sg64) {
502 			struct aac_sg_entry64 *sg64p =
503 			    (struct aac_sg_entry64 *)srb->sg.SgEntry;
504 
505 			usge->bcount = sg64p->SgByteCount;
506 			usge->addr = (caddr_t)
507 #ifndef _LP64
508 			    (uint32_t)
509 #endif
510 			    sg64p->SgAddress;
511 		} else {
512 			struct aac_sg_entry *sgp = srb->sg.SgEntry;
513 
514 			usge->bcount = sgp->SgByteCount;
515 			usge->addr = (caddr_t)
516 #ifdef _LP64
517 			    (uint64_t)
518 #endif
519 			    sgp->SgAddress;
520 		}
521 		acp->bcount += usge->bcount;
522 		if (usge->addr < addrlo)
523 			addrlo = usge->addr;
524 		if ((usge->addr + usge->bcount) > addrhi)
525 			addrhi = usge->addr + usge->bcount;
526 	}
527 	if (acp->bcount > softs->buf_dma_attr.dma_attr_maxxfer) {
528 		AACDB_PRINT(softs, CE_NOTE,
529 		    "large srb xfer size received %d\n", acp->bcount);
530 		rval = EINVAL;
531 		goto finish;
532 	}
533 
534 	/* Lock user buffers */
535 	if (srb->flags & SRB_DataIn) {
536 		umem_flags |= DDI_UMEMLOCK_READ;
537 		direct |= B_READ;
538 	}
539 	if (srb->flags & SRB_DataOut) {
540 		umem_flags |= DDI_UMEMLOCK_WRITE;
541 		direct |= B_WRITE;
542 	}
543 	addrlo = (caddr_t)((uintptr_t)addrlo & (uintptr_t)PAGEMASK);
544 	rval = ddi_umem_lock(addrlo, (((size_t)addrhi + PAGEOFFSET) & \
545 	    PAGEMASK) - (size_t)addrlo, umem_flags, &cookie);
546 	if (rval != 0) {
547 		AACDB_PRINT(softs, CE_NOTE, "ddi_umem_lock failed: %d",
548 		    rval);
549 		goto finish;
550 	}
551 	locked = 1;
552 
553 	/* Allocate DMA for user buffers */
554 	for (usge = usgt; usge < &usgt[srb_sgcount]; usge++) {
555 		struct buf *bp;
556 
557 		bp = ddi_umem_iosetup(cookie, (uintptr_t)usge->addr - \
558 		    (uintptr_t)addrlo, usge->bcount, direct, dev, 0, NULL,
559 		    DDI_UMEM_NOSLEEP);
560 		if (bp == NULL) {
561 			AACDB_PRINT(softs, CE_NOTE, "ddi_umem_iosetup failed");
562 			rval = ENOMEM;
563 			goto finish;
564 		}
565 		if (aac_cmd_dma_alloc(softs, &usge->acp, bp, 0, NULL_FUNC,
566 		    0) != AACOK) {
567 			rval = EFAULT;
568 			goto finish;
569 		}
570 		acp->left_cookien += usge->acp.left_cookien;
571 		if (acp->left_cookien > softs->aac_sg_tablesize) {
572 			AACDB_PRINT(softs, CE_NOTE, "large cookiec received %d",
573 			    acp->left_cookien);
574 			rval = EINVAL;
575 			goto finish;
576 		}
577 	}
578 
579 	/* Construct aac cmd SG table */
580 	if ((sge = kmem_zalloc(sizeof (struct aac_sge) * acp->left_cookien,
581 	    KM_NOSLEEP)) == NULL) {
582 		rval = ENOMEM;
583 		goto finish;
584 	}
585 	acp->sgt = sge;
586 	for (usge = usgt; usge < &usgt[srb_sgcount]; usge++) {
587 		for (sge0 = usge->acp.sgt;
588 		    sge0 < &usge->acp.sgt[usge->acp.left_cookien];
589 		    sge0++, sge++)
590 			*sge = *sge0;
591 	}
592 
593 send_fib:
594 	acp->cmdlen = srb->cdb_size;
595 	acp->timeout = srb->timeout;
596 
597 	/* Send FIB command */
598 	acp->aac_cmd_fib = softs->aac_cmd_fib_scsi;
599 #ifdef DEBUG
600 	acp->fib_flags = AACDB_FLAGS_FIB_SRB;
601 #endif
602 	if ((rval = aac_send_fib(softs, acp)) != 0)
603 		goto finish;
604 
605 	/* Status struct */
606 	if (ddi_copyout((struct aac_srb_reply *)fibp->data,
607 	    ((uint8_t *)arg + usr_fib_size),
608 	    sizeof (struct aac_srb_reply), mode) != 0) {
609 		rval = EFAULT;
610 		goto finish;
611 	}
612 
613 	rval = 0;
614 finish:
615 	if (acp->sgt)
616 		kmem_free(acp->sgt, sizeof (struct aac_sge) * \
617 		    acp->left_cookien);
618 	if (usgt) {
619 		for (usge = usgt; usge < &usgt[srb_sgcount]; usge++) {
620 			if (usge->acp.sgt)
621 				kmem_free(usge->acp.sgt,
622 				    sizeof (struct aac_sge) * \
623 				    usge->acp.left_cookien);
624 			aac_free_dmamap(&usge->acp);
625 			if (usge->acp.bp)
626 				freerbuf(usge->acp.bp);
627 		}
628 		kmem_free(usgt, sizeof (struct aac_umem_sge) * srb_sgcount);
629 	}
630 	if (locked)
631 		ddi_umem_unlock(cookie);
632 	kmem_free(acp, sizeof (struct aac_cmd) + usr_fib_size + \
633 	    sizeof (struct aac_fib_header));
634 	return (rval);
635 }
636 
637 /*ARGSUSED*/
638 static int
639 aac_get_pci_info(struct aac_softstate *softs, intptr_t arg, int mode)
640 {
641 	union aac_pci_info_align un;
642 	struct aac_pci_info *resp = &un.d;
643 	pci_regspec_t *pci_rp;
644 	uint_t num;
645 
646 	DBCALLED(softs, 2);
647 
648 	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, softs->devinfo_p,
649 	    DDI_PROP_DONTPASS, "reg", (int **)&pci_rp, &num) !=
650 	    DDI_PROP_SUCCESS)
651 		return (EINVAL);
652 	if (num < (sizeof (pci_regspec_t) / sizeof (int))) {
653 		ddi_prop_free(pci_rp);
654 		return (EINVAL);
655 	}
656 
657 	resp->bus = PCI_REG_BUS_G(pci_rp->pci_phys_hi);
658 	resp->slot = PCI_REG_DEV_G(pci_rp->pci_phys_hi);
659 	ddi_prop_free(pci_rp);
660 
661 	if (ddi_copyout(resp, (void *)arg,
662 	    sizeof (struct aac_pci_info), mode) != 0)
663 		return (EFAULT);
664 	return (0);
665 }
666 
667 static int
668 aac_query_disk(struct aac_softstate *softs, intptr_t arg, int mode)
669 {
670 	union aac_query_disk_align un;
671 	struct aac_query_disk *qdisk = &un.d;
672 	struct aac_container *dvp;
673 
674 	DBCALLED(softs, 2);
675 
676 	if (ddi_copyin((void *)arg, qdisk, sizeof (*qdisk), mode) != 0)
677 		return (EFAULT);
678 
679 	if (qdisk->container_no == -1) {
680 		qdisk->container_no = qdisk->target * 16 + qdisk->lun;
681 	} else if (qdisk->bus == -1 && qdisk->target == -1 &&
682 	    qdisk->lun == -1) {
683 		if (qdisk->container_no >= AAC_MAX_CONTAINERS)
684 			return (EINVAL);
685 		qdisk->bus = 0;
686 		qdisk->target = (qdisk->container_no & 0xf);
687 		qdisk->lun = (qdisk->container_no >> 4);
688 	} else {
689 		return (EINVAL);
690 	}
691 
692 	mutex_enter(&softs->io_lock);
693 	dvp = &softs->containers[qdisk->container_no];
694 	qdisk->valid = AAC_DEV_IS_VALID(&dvp->dev);
695 	qdisk->locked = dvp->locked;
696 	qdisk->deleted = dvp->deleted;
697 	mutex_exit(&softs->io_lock);
698 
699 	if (ddi_copyout(qdisk, (void *)arg, sizeof (*qdisk), mode) != 0)
700 		return (EFAULT);
701 	return (0);
702 }
703 
704 static int
705 aac_delete_disk(struct aac_softstate *softs, intptr_t arg, int mode)
706 {
707 	union aac_delete_disk_align un;
708 	struct aac_delete_disk *ddisk = &un.d;
709 	struct aac_container *dvp;
710 	int rval = 0;
711 
712 	DBCALLED(softs, 2);
713 
714 	if (ddi_copyin((void *)arg, ddisk, sizeof (*ddisk), mode) != 0)
715 		return (EFAULT);
716 
717 	if (ddisk->container_no >= AAC_MAX_CONTAINERS)
718 		return (EINVAL);
719 
720 	mutex_enter(&softs->io_lock);
721 	dvp = &softs->containers[ddisk->container_no];
722 	/*
723 	 * We don't trust the userland to tell us when to delete
724 	 * a container, rather we rely on an AIF coming from the
725 	 * controller.
726 	 */
727 	if (AAC_DEV_IS_VALID(&dvp->dev)) {
728 		if (dvp->locked)
729 			rval = EBUSY;
730 	}
731 	mutex_exit(&softs->io_lock);
732 
733 	return (rval);
734 }
735 
736 /*
737  * The following function comes from Adaptec to support creation of arrays
738  * bigger than 2TB.
739  */
740 static int
741 aac_supported_features(struct aac_softstate *softs, intptr_t arg, int mode)
742 {
743 	union aac_features_align un;
744 	struct aac_features *f = &un.d;
745 
746 	DBCALLED(softs, 2);
747 
748 	if (ddi_copyin((void *)arg, f, sizeof (*f), mode) != 0)
749 		return (EFAULT);
750 
751 	/*
752 	 * When the management driver receives FSACTL_GET_FEATURES ioctl with
753 	 * ALL zero in the featuresState, the driver will return the current
754 	 * state of all the supported features, the data field will not be
755 	 * valid.
756 	 * When the management driver receives FSACTL_GET_FEATURES ioctl with
757 	 * a specific bit set in the featuresState, the driver will return the
758 	 * current state of this specific feature and whatever data that are
759 	 * associated with the feature in the data field or perform whatever
760 	 * action needed indicates in the data field.
761 	 */
762 	if (f->feat.fValue == 0) {
763 		f->feat.fBits.largeLBA =
764 		    (softs->flags & AAC_FLAGS_LBA_64BIT) ? 1 : 0;
765 		f->feat.fBits.JBODSupport =
766 		    (softs->flags & AAC_FLAGS_JBOD) ? 1 : 0;
767 		/* TODO: In the future, add other features state here as well */
768 	} else {
769 		if (f->feat.fBits.largeLBA)
770 			f->feat.fBits.largeLBA =
771 			    (softs->flags & AAC_FLAGS_LBA_64BIT) ? 1 : 0;
772 		if (f->feat.fBits.JBODSupport)
773 			f->feat.fBits.JBODSupport =
774 			    (softs->flags & AAC_FLAGS_JBOD) ? 1 : 0;
775 		/* TODO: Add other features state and data in the future */
776 	}
777 
778 	if (ddi_copyout(f, (void *)arg, sizeof (*f), mode) != 0)
779 		return (EFAULT);
780 	return (0);
781 }
782