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