?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel/disk: Remove use of "%b" format.
[dragonfly.git] / sys / dev / raid / aac / aac.c
blob80ae06675c83932b67cd23b0149365d37593bff4
1 /*-
2 * Copyright (c) 2000 Michael Smith
3 * Copyright (c) 2001 Scott Long
4 * Copyright (c) 2000 BSDi
5 * Copyright (c) 2001 Adaptec, Inc.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * $FreeBSD: head/sys/dev/aac/aac.c 260044 2013-12-29 17:37:32Z marius $
30 */
31
32 /*
33 * Driver for the Adaptec 'FSA' family of PCI/SCSI RAID adapters.
34 */
35 #define AAC_DRIVERNAME "aac"
36
37 #include "opt_aac.h"
38
39 /* #include <stddef.h> */
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/malloc.h>
43 #include <sys/kernel.h>
44 #include <sys/kthread.h>
45 #include <sys/poll.h>
46
47 #include <sys/bus.h>
48 #include <sys/conf.h>
49 #include <sys/signalvar.h>
50 #include <sys/time.h>
51 #include <sys/eventhandler.h>
52 #include <sys/rman.h>
53
54 #include <sys/bus_dma.h>
55 #include <sys/device.h>
56 #include <sys/mplock2.h>
57
58 #include <bus/pci/pcireg.h>
59 #include <bus/pci/pcivar.h>
60
61 #include <dev/raid/aac/aacreg.h>
62 #include <dev/raid/aac/aac_ioctl.h>
63 #include <dev/raid/aac/aacvar.h>
64 #include <dev/raid/aac/aac_tables.h>
65
66 static void aac_startup(void *arg);
67 static void aac_add_container(struct aac_softc *sc,
68 struct aac_mntinforesp *mir, int f);
69 static void aac_get_bus_info(struct aac_softc *sc);
70 static void aac_daemon(void *arg);
71
72 /* Command Processing */
73 static void aac_timeout(struct aac_softc *sc);
74 static void aac_complete(void *context, int pending);
75 static int aac_bio_command(struct aac_softc *sc, struct aac_command **cmp);
76 static void aac_bio_complete(struct aac_command *cm);
77 static int aac_wait_command(struct aac_command *cm);
78 static void aac_command_thread(void *arg);
79
80 /* Command Buffer Management */
81 static void aac_map_command_sg(void *arg, bus_dma_segment_t *segs,
82 int nseg, int error);
83 static void aac_map_command_helper(void *arg, bus_dma_segment_t *segs,
84 int nseg, int error);
85 static int aac_alloc_commands(struct aac_softc *sc);
86 static void aac_free_commands(struct aac_softc *sc);
87 static void aac_unmap_command(struct aac_command *cm);
88
89 /* Hardware Interface */
90 static int aac_alloc(struct aac_softc *sc);
91 static void aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg,
92 int error);
93 static int aac_check_firmware(struct aac_softc *sc);
94 static int aac_init(struct aac_softc *sc);
95 static int aac_sync_command(struct aac_softc *sc, u_int32_t command,
96 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2,
97 u_int32_t arg3, u_int32_t *sp);
98 static int aac_setup_intr(struct aac_softc *sc);
99 static int aac_enqueue_fib(struct aac_softc *sc, int queue,
100 struct aac_command *cm);
101 static int aac_dequeue_fib(struct aac_softc *sc, int queue,
102 u_int32_t *fib_size, struct aac_fib **fib_addr);
103 static int aac_enqueue_response(struct aac_softc *sc, int queue,
104 struct aac_fib *fib);
105
106 /* StrongARM interface */
107 static int aac_sa_get_fwstatus(struct aac_softc *sc);
108 static void aac_sa_qnotify(struct aac_softc *sc, int qbit);
109 static int aac_sa_get_istatus(struct aac_softc *sc);
110 static void aac_sa_clear_istatus(struct aac_softc *sc, int mask);
111 static void aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command,
112 u_int32_t arg0, u_int32_t arg1,
113 u_int32_t arg2, u_int32_t arg3);
114 static int aac_sa_get_mailbox(struct aac_softc *sc, int mb);
115 static void aac_sa_set_interrupts(struct aac_softc *sc, int enable);
116
117 const struct aac_interface aac_sa_interface = {
118 aac_sa_get_fwstatus,
119 aac_sa_qnotify,
120 aac_sa_get_istatus,
121 aac_sa_clear_istatus,
122 aac_sa_set_mailbox,
123 aac_sa_get_mailbox,
124 aac_sa_set_interrupts,
125 NULL, NULL, NULL
126 };
127
128 /* i960Rx interface */
129 static int aac_rx_get_fwstatus(struct aac_softc *sc);
130 static void aac_rx_qnotify(struct aac_softc *sc, int qbit);
131 static int aac_rx_get_istatus(struct aac_softc *sc);
132 static void aac_rx_clear_istatus(struct aac_softc *sc, int mask);
133 static void aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command,
134 u_int32_t arg0, u_int32_t arg1,
135 u_int32_t arg2, u_int32_t arg3);
136 static int aac_rx_get_mailbox(struct aac_softc *sc, int mb);
137 static void aac_rx_set_interrupts(struct aac_softc *sc, int enable);
138 static int aac_rx_send_command(struct aac_softc *sc, struct aac_command *cm);
139 static int aac_rx_get_outb_queue(struct aac_softc *sc);
140 static void aac_rx_set_outb_queue(struct aac_softc *sc, int index);
141
142 const struct aac_interface aac_rx_interface = {
143 aac_rx_get_fwstatus,
144 aac_rx_qnotify,
145 aac_rx_get_istatus,
146 aac_rx_clear_istatus,
147 aac_rx_set_mailbox,
148 aac_rx_get_mailbox,
149 aac_rx_set_interrupts,
150 aac_rx_send_command,
151 aac_rx_get_outb_queue,
152 aac_rx_set_outb_queue
153 };
154
155 /* Rocket/MIPS interface */
156 static int aac_rkt_get_fwstatus(struct aac_softc *sc);
157 static void aac_rkt_qnotify(struct aac_softc *sc, int qbit);
158 static int aac_rkt_get_istatus(struct aac_softc *sc);
159 static void aac_rkt_clear_istatus(struct aac_softc *sc, int mask);
160 static void aac_rkt_set_mailbox(struct aac_softc *sc, u_int32_t command,
161 u_int32_t arg0, u_int32_t arg1,
162 u_int32_t arg2, u_int32_t arg3);
163 static int aac_rkt_get_mailbox(struct aac_softc *sc, int mb);
164 static void aac_rkt_set_interrupts(struct aac_softc *sc, int enable);
165 static int aac_rkt_send_command(struct aac_softc *sc, struct aac_command *cm);
166 static int aac_rkt_get_outb_queue(struct aac_softc *sc);
167 static void aac_rkt_set_outb_queue(struct aac_softc *sc, int index);
168
169 const struct aac_interface aac_rkt_interface = {
170 aac_rkt_get_fwstatus,
171 aac_rkt_qnotify,
172 aac_rkt_get_istatus,
173 aac_rkt_clear_istatus,
174 aac_rkt_set_mailbox,
175 aac_rkt_get_mailbox,
176 aac_rkt_set_interrupts,
177 aac_rkt_send_command,
178 aac_rkt_get_outb_queue,
179 aac_rkt_set_outb_queue
180 };
181
182 /* Debugging and Diagnostics */
183 static void aac_describe_controller(struct aac_softc *sc);
184 static const char *aac_describe_code(const struct aac_code_lookup *table,
185 u_int32_t code);
186
187 /* Management Interface */
188 static d_open_t aac_open;
189 static d_close_t aac_close;
190 static d_ioctl_t aac_ioctl;
191 static d_kqfilter_t aac_kqfilter;
192 static void aac_filter_detach(struct knote *kn);
193 static int aac_filter_read(struct knote *kn, long hint);
194 static int aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib);
195 static int aac_ioctl_send_raw_srb(struct aac_softc *sc, caddr_t arg);
196 static void aac_handle_aif(struct aac_softc *sc,
197 struct aac_fib *fib);
198 static int aac_rev_check(struct aac_softc *sc, caddr_t udata);
199 static int aac_open_aif(struct aac_softc *sc, caddr_t arg);
200 static int aac_close_aif(struct aac_softc *sc, caddr_t arg);
201 static int aac_getnext_aif(struct aac_softc *sc, caddr_t arg);
202 static int aac_return_aif(struct aac_softc *sc,
203 struct aac_fib_context *ctx, caddr_t uptr);
204 static int aac_query_disk(struct aac_softc *sc, caddr_t uptr);
205 static int aac_get_pci_info(struct aac_softc *sc, caddr_t uptr);
206 static int aac_supported_features(struct aac_softc *sc, caddr_t uptr);
207 static void aac_ioctl_event(struct aac_softc *sc,
208 struct aac_event *event, void *arg);
209 static struct aac_mntinforesp *
210 aac_get_container_info(struct aac_softc *sc, struct aac_fib *fib, int cid);
211
212 static struct dev_ops aac_ops = {
213 { "aac", 0, 0 },
214 .d_open = aac_open,
215 .d_close = aac_close,
216 .d_ioctl = aac_ioctl,
217 .d_kqfilter = aac_kqfilter
218 };
219
220 static MALLOC_DEFINE(M_AACBUF, "aacbuf", "Buffers for the AAC driver");
221
222 /* sysctl node */
223 SYSCTL_NODE(_hw, OID_AUTO, aac, CTLFLAG_RD, 0, "AAC driver parameters");
224
225 /*
226 * Device Interface
227 */
228
229 /*
230 * Initialize the controller and softc
231 */
232 int
233 aac_attach(struct aac_softc *sc)
234 {
235 int error, unit;
236
237 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
238
239 /*
240 * Initialize per-controller queues.
241 */
242 aac_initq_free(sc);
243 aac_initq_ready(sc);
244 aac_initq_busy(sc);
245 aac_initq_bio(sc);
246
247 /*
248 * Initialize command-completion task.
249 */
250 TASK_INIT(&sc->aac_task_complete, 0, aac_complete, sc);
251
252 /* mark controller as suspended until we get ourselves organised */
253 sc->aac_state |= AAC_STATE_SUSPEND;
254
255 /*
256 * Check that the firmware on the card is supported.
257 */
258 if ((error = aac_check_firmware(sc)) != 0)
259 return(error);
260
261 /*
262 * Initialize locks
263 */
264 lockinit(&sc->aac_aifq_lock, "AAC AIF lock", 0, LK_CANRECURSE);
265 lockinit(&sc->aac_io_lock, "AAC I/O lock", 0, LK_CANRECURSE);
266 lockinit(&sc->aac_container_lock, "AAC container lock", 0, LK_CANRECURSE);
267 TAILQ_INIT(&sc->aac_container_tqh);
268 TAILQ_INIT(&sc->aac_ev_cmfree);
269
270 /* Initialize the clock daemon callout. */
271 callout_init_mp(&sc->aac_daemontime);
272
273 /*
274 * Initialize the adapter.
275 */
276 if ((error = aac_alloc(sc)) != 0)
277 return(error);
278 if ((error = aac_init(sc)) != 0)
279 return(error);
280
281 /*
282 * Allocate and connect our interrupt.
283 */
284 if ((error = aac_setup_intr(sc)) != 0)
285 return(error);
286
287 /*
288 * Print a little information about the controller.
289 */
290 aac_describe_controller(sc);
291
292 /*
293 * Add sysctls.
294 */
295 SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->aac_dev),
296 SYSCTL_CHILDREN(device_get_sysctl_tree(sc->aac_dev)),
297 OID_AUTO, "firmware_build", CTLFLAG_RD,
298 &sc->aac_revision.buildNumber, 0,
299 "firmware build number");
300
301 /*
302 * Register to probe our containers later.
303 */
304 sc->aac_ich.ich_func = aac_startup;
305 sc->aac_ich.ich_arg = sc;
306 sc->aac_ich.ich_desc = "aac";
307 if (config_intrhook_establish(&sc->aac_ich) != 0) {
308 device_printf(sc->aac_dev,
309 "can't establish configuration hook\n");
310 return(ENXIO);
311 }
312
313 /*
314 * Make the control device.
315 */
316 unit = device_get_unit(sc->aac_dev);
317 sc->aac_dev_t = make_dev(&aac_ops, unit, UID_ROOT, GID_OPERATOR,
318 0640, "aac%d", unit);
319 (void)make_dev_alias(sc->aac_dev_t, "afa%d", unit);
320 (void)make_dev_alias(sc->aac_dev_t, "hpn%d", unit);
321 sc->aac_dev_t->si_drv1 = sc;
322
323 /* Create the AIF thread */
324 if (kthread_create(aac_command_thread, sc,
325 &sc->aifthread, "aac%daif", unit))
326 panic("Could not create AIF thread");
327
328 /* Register the shutdown method to only be called post-dump */
329 if ((sc->eh = EVENTHANDLER_REGISTER(shutdown_final, aac_shutdown,
330 sc->aac_dev, SHUTDOWN_PRI_DEFAULT)) == NULL)
331 device_printf(sc->aac_dev,
332 "shutdown event registration failed\n");
333
334 /* Register with CAM for the non-DASD devices */
335 if ((sc->flags & AAC_FLAGS_ENABLE_CAM) != 0) {
336 TAILQ_INIT(&sc->aac_sim_tqh);
337 aac_get_bus_info(sc);
338 }
339
340 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
341 callout_reset(&sc->aac_daemontime, 60 * hz, aac_daemon, sc);
342 lockmgr(&sc->aac_io_lock, LK_RELEASE);
343
344 return(0);
345 }
346
347 static void
348 aac_daemon(void *arg)
349 {
350 struct timeval tv;
351 struct aac_softc *sc;
352 struct aac_fib *fib;
353
354 sc = arg;
355 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
356
357 if (callout_pending(&sc->aac_daemontime) ||
358 callout_active(&sc->aac_daemontime) == 0) {
359 lockmgr(&sc->aac_io_lock, LK_RELEASE);
360 return;
361 }
362 getmicrotime(&tv);
363 aac_alloc_sync_fib(sc, &fib);
364 *(uint32_t *)fib->data = tv.tv_sec;
365 aac_sync_fib(sc, SendHostTime, 0, fib, sizeof(uint32_t));
366 aac_release_sync_fib(sc);
367 callout_reset(&sc->aac_daemontime, 30 * 60 * hz, aac_daemon, sc);
368 lockmgr(&sc->aac_io_lock, LK_RELEASE);
369 }
370
371 void
372 aac_add_event(struct aac_softc *sc, struct aac_event *event)
373 {
374
375 switch (event->ev_type & AAC_EVENT_MASK) {
376 case AAC_EVENT_CMFREE:
377 TAILQ_INSERT_TAIL(&sc->aac_ev_cmfree, event, ev_links);
378 break;
379 default:
380 device_printf(sc->aac_dev, "aac_add event: unknown event %d\n",
381 event->ev_type);
382 break;
383 }
384 }
385
386 /*
387 * Request information of container #cid
388 */
389 static struct aac_mntinforesp *
390 aac_get_container_info(struct aac_softc *sc, struct aac_fib *fib, int cid)
391 {
392 struct aac_mntinfo *mi;
393
394 mi = (struct aac_mntinfo *)&fib->data[0];
395 /* use 64-bit LBA if enabled */
396 mi->Command = (sc->flags & AAC_FLAGS_LBA_64BIT) ?
397 VM_NameServe64 : VM_NameServe;
398 mi->MntType = FT_FILESYS;
399 mi->MntCount = cid;
400
401 if (aac_sync_fib(sc, ContainerCommand, 0, fib,
402 sizeof(struct aac_mntinfo))) {
403 device_printf(sc->aac_dev, "Error probing container %d\n", cid);
404 return (NULL);
405 }
406
407 return ((struct aac_mntinforesp *)&fib->data[0]);
408 }
409
410 /*
411 * Probe for containers, create disks.
412 */
413 static void
414 aac_startup(void *arg)
415 {
416 struct aac_softc *sc;
417 struct aac_fib *fib;
418 struct aac_mntinforesp *mir;
419 int count = 0, i = 0;
420
421 sc = (struct aac_softc *)arg;
422 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
423
424 /* disconnect ourselves from the intrhook chain */
425 config_intrhook_disestablish(&sc->aac_ich);
426
427 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
428 aac_alloc_sync_fib(sc, &fib);
429
430 /* loop over possible containers */
431 do {
432 if ((mir = aac_get_container_info(sc, fib, i)) == NULL)
433 continue;
434 if (i == 0)
435 count = mir->MntRespCount;
436 aac_add_container(sc, mir, 0);
437 i++;
438 } while ((i < count) && (i < AAC_MAX_CONTAINERS));
439
440 aac_release_sync_fib(sc);
441 lockmgr(&sc->aac_io_lock, LK_RELEASE);
442
443 /* poke the bus to actually attach the child devices */
444 if (bus_generic_attach(sc->aac_dev))
445 device_printf(sc->aac_dev, "bus_generic_attach failed\n");
446
447 /* mark the controller up */
448 sc->aac_state &= ~AAC_STATE_SUSPEND;
449
450 /* enable interrupts now */
451 AAC_UNMASK_INTERRUPTS(sc);
452 }
453
454 /*
455 * Create a device to represent a new container
456 */
457 static void
458 aac_add_container(struct aac_softc *sc, struct aac_mntinforesp *mir, int f)
459 {
460 struct aac_container *co;
461 device_t child;
462
463 /*
464 * Check container volume type for validity. Note that many of
465 * the possible types may never show up.
466 */
467 if ((mir->Status == ST_OK) && (mir->MntTable[0].VolType != CT_NONE)) {
468 co = (struct aac_container *)kmalloc(sizeof *co, M_AACBUF,
469 M_INTWAIT | M_ZERO);
470 fwprintf(sc, HBA_FLAGS_DBG_INIT_B, "id %x name '%.16s' size %u type %d",
471 mir->MntTable[0].ObjectId,
472 mir->MntTable[0].FileSystemName,
473 mir->MntTable[0].Capacity, mir->MntTable[0].VolType);
474
475 if ((child = device_add_child(sc->aac_dev, "aacd", -1)) == NULL)
476 device_printf(sc->aac_dev, "device_add_child failed\n");
477 else
478 device_set_ivars(child, co);
479 device_set_desc(child, aac_describe_code(aac_container_types,
480 mir->MntTable[0].VolType));
481 co->co_disk = child;
482 co->co_found = f;
483 bcopy(&mir->MntTable[0], &co->co_mntobj,
484 sizeof(struct aac_mntobj));
485 lockmgr(&sc->aac_container_lock, LK_EXCLUSIVE);
486 TAILQ_INSERT_TAIL(&sc->aac_container_tqh, co, co_link);
487 lockmgr(&sc->aac_container_lock, LK_RELEASE);
488 }
489 }
490
491 /*
492 * Allocate resources associated with (sc)
493 */
494 static int
495 aac_alloc(struct aac_softc *sc)
496 {
497
498 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
499
500 /*
501 * Create DMA tag for mapping buffers into controller-addressable space.
502 */
503 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
504 1, 0, /* algnmnt, boundary */
505 (sc->flags & AAC_FLAGS_SG_64BIT) ?
506 BUS_SPACE_MAXADDR :
507 BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
508 BUS_SPACE_MAXADDR, /* highaddr */
509 NULL, NULL, /* filter, filterarg */
510 MAXBSIZE, /* maxsize */
511 sc->aac_sg_tablesize, /* nsegments */
512 MAXBSIZE, /* maxsegsize */
513 BUS_DMA_ALLOCNOW, /* flags */
514 &sc->aac_buffer_dmat)) {
515 device_printf(sc->aac_dev, "can't allocate buffer DMA tag\n");
516 return (ENOMEM);
517 }
518
519 /*
520 * Create DMA tag for mapping FIBs into controller-addressable space..
521 */
522 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
523 1, 0, /* algnmnt, boundary */
524 (sc->flags & AAC_FLAGS_4GB_WINDOW) ?
525 BUS_SPACE_MAXADDR_32BIT :
526 0x7fffffff, /* lowaddr */
527 BUS_SPACE_MAXADDR, /* highaddr */
528 NULL, NULL, /* filter, filterarg */
529 sc->aac_max_fibs_alloc *
530 sc->aac_max_fib_size, /* maxsize */
531 1, /* nsegments */
532 sc->aac_max_fibs_alloc *
533 sc->aac_max_fib_size, /* maxsize */
534 0, /* flags */
535 &sc->aac_fib_dmat)) {
536 device_printf(sc->aac_dev, "can't allocate FIB DMA tag\n");
537 return (ENOMEM);
538 }
539
540 /*
541 * Create DMA tag for the common structure and allocate it.
542 */
543 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
544 1, 0, /* algnmnt, boundary */
545 (sc->flags & AAC_FLAGS_4GB_WINDOW) ?
546 BUS_SPACE_MAXADDR_32BIT :
547 0x7fffffff, /* lowaddr */
548 BUS_SPACE_MAXADDR, /* highaddr */
549 NULL, NULL, /* filter, filterarg */
550 8192 + sizeof(struct aac_common), /* maxsize */
551 1, /* nsegments */
552 BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
553 0, /* flags */
554 &sc->aac_common_dmat)) {
555 device_printf(sc->aac_dev,
556 "can't allocate common structure DMA tag\n");
557 return (ENOMEM);
558 }
559 if (bus_dmamem_alloc(sc->aac_common_dmat, (void **)&sc->aac_common,
560 BUS_DMA_NOWAIT, &sc->aac_common_dmamap)) {
561 device_printf(sc->aac_dev, "can't allocate common structure\n");
562 return (ENOMEM);
563 }
564
565 /*
566 * Work around a bug in the 2120 and 2200 that cannot DMA commands
567 * below address 8192 in physical memory.
568 * XXX If the padding is not needed, can it be put to use instead
569 * of ignored?
570 */
571 (void)bus_dmamap_load(sc->aac_common_dmat, sc->aac_common_dmamap,
572 sc->aac_common, 8192 + sizeof(*sc->aac_common),
573 aac_common_map, sc, 0);
574
575 if (sc->aac_common_busaddr < 8192) {
576 sc->aac_common = (struct aac_common *)
577 ((uint8_t *)sc->aac_common + 8192);
578 sc->aac_common_busaddr += 8192;
579 }
580 bzero(sc->aac_common, sizeof(*sc->aac_common));
581
582 /* Allocate some FIBs and associated command structs */
583 TAILQ_INIT(&sc->aac_fibmap_tqh);
584 sc->aac_commands = kmalloc(sc->aac_max_fibs * sizeof(struct aac_command),
585 M_AACBUF, M_WAITOK|M_ZERO);
586 while (sc->total_fibs < sc->aac_max_fibs) {
587 if (aac_alloc_commands(sc) != 0)
588 break;
589 }
590 if (sc->total_fibs == 0)
591 return (ENOMEM);
592
593 return (0);
594 }
595
596 /*
597 * Free all of the resources associated with (sc)
598 *
599 * Should not be called if the controller is active.
600 */
601 void
602 aac_free(struct aac_softc *sc)
603 {
604
605 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
606
607 /* remove the control device */
608 if (sc->aac_dev_t != NULL)
609 destroy_dev(sc->aac_dev_t);
610
611 /* throw away any FIB buffers, discard the FIB DMA tag */
612 aac_free_commands(sc);
613 if (sc->aac_fib_dmat)
614 bus_dma_tag_destroy(sc->aac_fib_dmat);
615
616 kfree(sc->aac_commands, M_AACBUF);
617
618 /* destroy the common area */
619 if (sc->aac_common) {
620 bus_dmamap_unload(sc->aac_common_dmat, sc->aac_common_dmamap);
621 bus_dmamem_free(sc->aac_common_dmat, sc->aac_common,
622 sc->aac_common_dmamap);
623 }
624 if (sc->aac_common_dmat)
625 bus_dma_tag_destroy(sc->aac_common_dmat);
626
627 /* disconnect the interrupt handler */
628 if (sc->aac_intr)
629 bus_teardown_intr(sc->aac_dev, sc->aac_irq, sc->aac_intr);
630 if (sc->aac_irq != NULL) {
631 bus_release_resource(sc->aac_dev, SYS_RES_IRQ,
632 rman_get_rid(sc->aac_irq), sc->aac_irq);
633 if (sc->aac_irq_type == PCI_INTR_TYPE_MSI)
634 pci_release_msi(sc->aac_dev);
635 }
636
637 /* destroy data-transfer DMA tag */
638 if (sc->aac_buffer_dmat)
639 bus_dma_tag_destroy(sc->aac_buffer_dmat);
640
641 /* destroy the parent DMA tag */
642 if (sc->aac_parent_dmat)
643 bus_dma_tag_destroy(sc->aac_parent_dmat);
644
645 /* release the register window mapping */
646 if (sc->aac_regs_res0 != NULL)
647 bus_release_resource(sc->aac_dev, SYS_RES_MEMORY,
648 rman_get_rid(sc->aac_regs_res0), sc->aac_regs_res0);
649 if (sc->aac_hwif == AAC_HWIF_NARK && sc->aac_regs_res1 != NULL)
650 bus_release_resource(sc->aac_dev, SYS_RES_MEMORY,
651 rman_get_rid(sc->aac_regs_res1), sc->aac_regs_res1);
652 dev_ops_remove_minor(&aac_ops, device_get_unit(sc->aac_dev));
653 }
654
655 /*
656 * Disconnect from the controller completely, in preparation for unload.
657 */
658 int
659 aac_detach(device_t dev)
660 {
661 struct aac_softc *sc;
662 struct aac_container *co;
663 struct aac_sim *sim;
664 int error;
665
666 sc = device_get_softc(dev);
667 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
668
669 callout_stop_sync(&sc->aac_daemontime);
670
671 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
672 while (sc->aifflags & AAC_AIFFLAGS_RUNNING) {
673 sc->aifflags |= AAC_AIFFLAGS_EXIT;
674 wakeup(sc->aifthread);
675 lksleep(sc->aac_dev, &sc->aac_io_lock, 0, "aacdch", 0);
676 }
677 lockmgr(&sc->aac_io_lock, LK_RELEASE);
678 KASSERT((sc->aifflags & AAC_AIFFLAGS_RUNNING) == 0,
679 ("%s: invalid detach state", __func__));
680
681 /* Remove the child containers */
682 while ((co = TAILQ_FIRST(&sc->aac_container_tqh)) != NULL) {
683 error = device_delete_child(dev, co->co_disk);
684 if (error)
685 return (error);
686 TAILQ_REMOVE(&sc->aac_container_tqh, co, co_link);
687 kfree(co, M_AACBUF);
688 }
689
690 /* Remove the CAM SIMs */
691 while ((sim = TAILQ_FIRST(&sc->aac_sim_tqh)) != NULL) {
692 TAILQ_REMOVE(&sc->aac_sim_tqh, sim, sim_link);
693 error = device_delete_child(dev, sim->sim_dev);
694 if (error)
695 return (error);
696 kfree(sim, M_AACBUF);
697 }
698
699 if ((error = aac_shutdown(dev)))
700 return(error);
701
702 EVENTHANDLER_DEREGISTER(shutdown_final, sc->eh);
703
704 aac_free(sc);
705
706 lockuninit(&sc->aac_aifq_lock);
707 lockuninit(&sc->aac_io_lock);
708 lockuninit(&sc->aac_container_lock);
709
710 return(0);
711 }
712
713 /*
714 * Bring the controller down to a dormant state and detach all child devices.
715 *
716 * This function is called before detach or system shutdown.
717 *
718 * Note that we can assume that the bioq on the controller is empty, as we won't
719 * allow shutdown if any device is open.
720 */
721 int
722 aac_shutdown(device_t dev)
723 {
724 struct aac_softc *sc;
725 struct aac_fib *fib;
726 struct aac_close_command *cc;
727
728 sc = device_get_softc(dev);
729 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
730
731 sc->aac_state |= AAC_STATE_SUSPEND;
732
733 /*
734 * Send a Container shutdown followed by a HostShutdown FIB to the
735 * controller to convince it that we don't want to talk to it anymore.
736 * We've been closed and all I/O completed already
737 */
738 device_printf(sc->aac_dev, "shutting down controller...");
739
740 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
741 aac_alloc_sync_fib(sc, &fib);
742 cc = (struct aac_close_command *)&fib->data[0];
743
744 bzero(cc, sizeof(struct aac_close_command));
745 cc->Command = VM_CloseAll;
746 cc->ContainerId = 0xffffffff;
747 if (aac_sync_fib(sc, ContainerCommand, 0, fib,
748 sizeof(struct aac_close_command)))
749 kprintf("FAILED.\n");
750 else
751 kprintf("done\n");
752 #if 0
753 else {
754 fib->data[0] = 0;
755 /*
756 * XXX Issuing this command to the controller makes it shut down
757 * but also keeps it from coming back up without a reset of the
758 * PCI bus. This is not desirable if you are just unloading the
759 * driver module with the intent to reload it later.
760 */
761 if (aac_sync_fib(sc, FsaHostShutdown, AAC_FIBSTATE_SHUTDOWN,
762 fib, 1)) {
763 kprintf("FAILED.\n");
764 } else {
765 kprintf("done.\n");
766 }
767 }
768 #endif
769
770 AAC_MASK_INTERRUPTS(sc);
771 aac_release_sync_fib(sc);
772 lockmgr(&sc->aac_io_lock, LK_RELEASE);
773
774 return(0);
775 }
776
777 /*
778 * Bring the controller to a quiescent state, ready for system suspend.
779 */
780 int
781 aac_suspend(device_t dev)
782 {
783 struct aac_softc *sc;
784
785 sc = device_get_softc(dev);
786
787 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
788 sc->aac_state |= AAC_STATE_SUSPEND;
789
790 AAC_MASK_INTERRUPTS(sc);
791 return(0);
792 }
793
794 /*
795 * Bring the controller back to a state ready for operation.
796 */
797 int
798 aac_resume(device_t dev)
799 {
800 struct aac_softc *sc;
801
802 sc = device_get_softc(dev);
803
804 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
805 sc->aac_state &= ~AAC_STATE_SUSPEND;
806 AAC_UNMASK_INTERRUPTS(sc);
807 return(0);
808 }
809
810 /*
811 * Interrupt handler for NEW_COMM interface.
812 */
813 void
814 aac_new_intr(void *arg)
815 {
816 struct aac_softc *sc;
817 u_int32_t index, fast;
818 struct aac_command *cm;
819 struct aac_fib *fib;
820 int i;
821
822 sc = (struct aac_softc *)arg;
823
824 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
825 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
826 while (1) {
827 index = AAC_GET_OUTB_QUEUE(sc);
828 if (index == 0xffffffff)
829 index = AAC_GET_OUTB_QUEUE(sc);
830 if (index == 0xffffffff)
831 break;
832 if (index & 2) {
833 if (index == 0xfffffffe) {
834 /* XXX This means that the controller wants
835 * more work. Ignore it for now.
836 */
837 continue;
838 }
839 /* AIF */
840 fib = (struct aac_fib *)kmalloc(sizeof *fib, M_AACBUF,
841 M_INTWAIT | M_ZERO);
842 index &= ~2;
843 for (i = 0; i < sizeof(struct aac_fib)/4; ++i)
844 ((u_int32_t *)fib)[i] = AAC_MEM1_GETREG4(sc, index + i*4);
845 aac_handle_aif(sc, fib);
846 kfree(fib, M_AACBUF);
847
848 /*
849 * AIF memory is owned by the adapter, so let it
850 * know that we are done with it.
851 */
852 AAC_SET_OUTB_QUEUE(sc, index);
853 AAC_CLEAR_ISTATUS(sc, AAC_DB_RESPONSE_READY);
854 } else {
855 fast = index & 1;
856 cm = sc->aac_commands + (index >> 2);
857 fib = cm->cm_fib;
858 if (fast) {
859 fib->Header.XferState |= AAC_FIBSTATE_DONEADAP;
860 *((u_int32_t *)(fib->data)) = AAC_ERROR_NORMAL;
861 }
862 aac_remove_busy(cm);
863 aac_unmap_command(cm);
864 cm->cm_flags |= AAC_CMD_COMPLETED;
865
866 /* is there a completion handler? */
867 if (cm->cm_complete != NULL) {
868 cm->cm_complete(cm);
869 } else {
870 /* assume that someone is sleeping on this
871 * command
872 */
873 wakeup(cm);
874 }
875 sc->flags &= ~AAC_QUEUE_FRZN;
876 }
877 }
878 /* see if we can start some more I/O */
879 if ((sc->flags & AAC_QUEUE_FRZN) == 0)
880 aac_startio(sc);
881
882 lockmgr(&sc->aac_io_lock, LK_RELEASE);
883 }
884
885 /*
886 * Interrupt filter for !NEW_COMM interface.
887 */
888 void
889 aac_filter(void *arg)
890 {
891 struct aac_softc *sc;
892 u_int16_t reason;
893
894 sc = (struct aac_softc *)arg;
895
896 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
897 /*
898 * Read the status register directly. This is faster than taking the
899 * driver lock and reading the queues directly. It also saves having
900 * to turn parts of the driver lock into a spin mutex, which would be
901 * ugly.
902 */
903 reason = AAC_GET_ISTATUS(sc);
904 AAC_CLEAR_ISTATUS(sc, reason);
905
906 /* handle completion processing */
907 if (reason & AAC_DB_RESPONSE_READY)
908 taskqueue_enqueue(taskqueue_swi, &sc->aac_task_complete);
909
910 /* controller wants to talk to us */
911 if (reason & (AAC_DB_PRINTF | AAC_DB_COMMAND_READY)) {
912 /*
913 * XXX Make sure that we don't get fooled by strange messages
914 * that start with a NULL.
915 */
916 if ((reason & AAC_DB_PRINTF) &&
917 (sc->aac_common->ac_printf[0] == 0))
918 sc->aac_common->ac_printf[0] = 32;
919
920 /*
921 * This might miss doing the actual wakeup. However, the
922 * lksleep that this is waking up has a timeout, so it will
923 * wake up eventually. AIFs and printfs are low enough
924 * priority that they can handle hanging out for a few seconds
925 * if needed.
926 */
927 wakeup(sc->aifthread);
928 }
929 }
930
931 /*
932 * Command Processing
933 */
934
935 /*
936 * Start as much queued I/O as possible on the controller
937 */
938 void
939 aac_startio(struct aac_softc *sc)
940 {
941 struct aac_command *cm;
942 int error;
943
944 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
945
946 for (;;) {
947 /*
948 * This flag might be set if the card is out of resources.
949 * Checking it here prevents an infinite loop of deferrals.
950 */
951 if (sc->flags & AAC_QUEUE_FRZN)
952 break;
953
954 /*
955 * Try to get a command that's been put off for lack of
956 * resources
957 */
958 cm = aac_dequeue_ready(sc);
959
960 /*
961 * Try to build a command off the bio queue (ignore error
962 * return)
963 */
964 if (cm == NULL)
965 aac_bio_command(sc, &cm);
966
967 /* nothing to do? */
968 if (cm == NULL)
969 break;
970
971 /* don't map more than once */
972 if (cm->cm_flags & AAC_CMD_MAPPED)
973 panic("aac: command %p already mapped", cm);
974
975 /*
976 * Set up the command to go to the controller. If there are no
977 * data buffers associated with the command then it can bypass
978 * busdma.
979 */
980 if (cm->cm_datalen != 0) {
981 error = bus_dmamap_load(sc->aac_buffer_dmat,
982 cm->cm_datamap, cm->cm_data,
983 cm->cm_datalen,
984 aac_map_command_sg, cm, 0);
985 if (error == EINPROGRESS) {
986 fwprintf(sc, HBA_FLAGS_DBG_COMM_B, "freezing queue\n");
987 sc->flags |= AAC_QUEUE_FRZN;
988 error = 0;
989 } else if (error != 0)
990 panic("aac_startio: unexpected error %d from "
991 "busdma", error);
992 } else
993 aac_map_command_sg(cm, NULL, 0, 0);
994 }
995 }
996
997 /*
998 * Handle notification of one or more FIBs coming from the controller.
999 */
1000 static void
1001 aac_command_thread(void *arg)
1002 {
1003 struct aac_softc *sc = arg;
1004 struct aac_fib *fib;
1005 u_int32_t fib_size;
1006 int size, retval;
1007
1008 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1009
1010 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
1011 sc->aifflags = AAC_AIFFLAGS_RUNNING;
1012
1013 while ((sc->aifflags & AAC_AIFFLAGS_EXIT) == 0) {
1014
1015 retval = 0;
1016 if ((sc->aifflags & AAC_AIFFLAGS_PENDING) == 0)
1017 retval = lksleep(sc->aifthread, &sc->aac_io_lock, 0,
1018 "aifthd", AAC_PERIODIC_INTERVAL * hz);
1019
1020 /*
1021 * First see if any FIBs need to be allocated. This needs
1022 * to be called without the driver lock because contigmalloc
1023 * can sleep.
1024 */
1025 if ((sc->aifflags & AAC_AIFFLAGS_ALLOCFIBS) != 0) {
1026 lockmgr(&sc->aac_io_lock, LK_RELEASE);
1027 aac_alloc_commands(sc);
1028 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
1029 sc->aifflags &= ~AAC_AIFFLAGS_ALLOCFIBS;
1030 aac_startio(sc);
1031 }
1032
1033 /*
1034 * While we're here, check to see if any commands are stuck.
1035 * This is pretty low-priority, so it's ok if it doesn't
1036 * always fire.
1037 */
1038 if (retval == EWOULDBLOCK)
1039 aac_timeout(sc);
1040
1041 /* Check the hardware printf message buffer */
1042 if (sc->aac_common->ac_printf[0] != 0)
1043 aac_print_printf(sc);
1044
1045 /* Also check to see if the adapter has a command for us. */
1046 if (sc->flags & AAC_FLAGS_NEW_COMM)
1047 continue;
1048 for (;;) {
1049 if (aac_dequeue_fib(sc, AAC_HOST_NORM_CMD_QUEUE,
1050 &fib_size, &fib))
1051 break;
1052
1053 AAC_PRINT_FIB(sc, fib);
1054
1055 switch (fib->Header.Command) {
1056 case AifRequest:
1057 aac_handle_aif(sc, fib);
1058 break;
1059 default:
1060 device_printf(sc->aac_dev, "unknown command "
1061 "from controller\n");
1062 break;
1063 }
1064
1065 if ((fib->Header.XferState == 0) ||
1066 (fib->Header.StructType != AAC_FIBTYPE_TFIB)) {
1067 break;
1068 }
1069
1070 /* Return the AIF to the controller. */
1071 if (fib->Header.XferState & AAC_FIBSTATE_FROMADAP) {
1072 fib->Header.XferState |= AAC_FIBSTATE_DONEHOST;
1073 *(AAC_FSAStatus*)fib->data = ST_OK;
1074
1075 /* XXX Compute the Size field? */
1076 size = fib->Header.Size;
1077 if (size > sizeof(struct aac_fib)) {
1078 size = sizeof(struct aac_fib);
1079 fib->Header.Size = size;
1080 }
1081 /*
1082 * Since we did not generate this command, it
1083 * cannot go through the normal
1084 * enqueue->startio chain.
1085 */
1086 aac_enqueue_response(sc,
1087 AAC_ADAP_NORM_RESP_QUEUE,
1088 fib);
1089 }
1090 }
1091 }
1092 sc->aifflags &= ~AAC_AIFFLAGS_RUNNING;
1093 lockmgr(&sc->aac_io_lock, LK_RELEASE);
1094 wakeup(sc->aac_dev);
1095 }
1096
1097 /*
1098 * Process completed commands.
1099 */
1100 static void
1101 aac_complete(void *context, int pending)
1102 {
1103 struct aac_softc *sc;
1104 struct aac_command *cm;
1105 struct aac_fib *fib;
1106 u_int32_t fib_size;
1107
1108 sc = (struct aac_softc *)context;
1109 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1110
1111 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
1112
1113 /* pull completed commands off the queue */
1114 for (;;) {
1115 /* look for completed FIBs on our queue */
1116 if (aac_dequeue_fib(sc, AAC_HOST_NORM_RESP_QUEUE, &fib_size,
1117 &fib))
1118 break; /* nothing to do */
1119
1120 /* get the command, unmap and hand off for processing */
1121 cm = sc->aac_commands + fib->Header.SenderData;
1122 if (cm == NULL) {
1123 AAC_PRINT_FIB(sc, fib);
1124 break;
1125 }
1126 if ((cm->cm_flags & AAC_CMD_TIMEDOUT) != 0)
1127 device_printf(sc->aac_dev,
1128 "COMMAND %p COMPLETED AFTER %d SECONDS\n",
1129 cm, (int)(time_uptime - cm->cm_timestamp));
1130
1131 aac_remove_busy(cm);
1132
1133 aac_unmap_command(cm);
1134 cm->cm_flags |= AAC_CMD_COMPLETED;
1135
1136 /* is there a completion handler? */
1137 if (cm->cm_complete != NULL) {
1138 cm->cm_complete(cm);
1139 } else {
1140 /* assume that someone is sleeping on this command */
1141 wakeup(cm);
1142 }
1143 }
1144
1145 /* see if we can start some more I/O */
1146 sc->flags &= ~AAC_QUEUE_FRZN;
1147 aac_startio(sc);
1148
1149 lockmgr(&sc->aac_io_lock, LK_RELEASE);
1150 }
1151
1152 /*
1153 * Handle a bio submitted from a disk device.
1154 */
1155 void
1156 aac_submit_bio(struct aac_disk *ad, struct bio *bio)
1157 {
1158 struct aac_softc *sc;
1159
1160 bio->bio_driver_info = ad;
1161 sc = ad->ad_controller;
1162 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1163
1164 /* queue the BIO and try to get some work done */
1165 aac_enqueue_bio(sc, bio);
1166 aac_startio(sc);
1167 }
1168
1169 /*
1170 * Get a bio and build a command to go with it.
1171 */
1172 static int
1173 aac_bio_command(struct aac_softc *sc, struct aac_command **cmp)
1174 {
1175 struct aac_command *cm;
1176 struct aac_fib *fib;
1177 struct aac_disk *ad;
1178 struct bio *bio;
1179 struct buf *bp;
1180
1181 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1182
1183 /* get the resources we will need */
1184 cm = NULL;
1185 bio = NULL;
1186 if (aac_alloc_command(sc, &cm)) /* get a command */
1187 goto fail;
1188 if ((bio = aac_dequeue_bio(sc)) == NULL)
1189 goto fail;
1190
1191 /* fill out the command */
1192 bp = bio->bio_buf;
1193 cm->cm_data = (void *)bp->b_data;
1194 cm->cm_datalen = bp->b_bcount;
1195 cm->cm_complete = aac_bio_complete;
1196 cm->cm_private = bio;
1197 cm->cm_timestamp = time_uptime;
1198
1199 /* build the FIB */
1200 fib = cm->cm_fib;
1201 fib->Header.Size = sizeof(struct aac_fib_header);
1202 fib->Header.XferState =
1203 AAC_FIBSTATE_HOSTOWNED |
1204 AAC_FIBSTATE_INITIALISED |
1205 AAC_FIBSTATE_EMPTY |
1206 AAC_FIBSTATE_FROMHOST |
1207 AAC_FIBSTATE_REXPECTED |
1208 AAC_FIBSTATE_NORM |
1209 AAC_FIBSTATE_ASYNC |
1210 AAC_FIBSTATE_FAST_RESPONSE;
1211
1212 /* build the read/write request */
1213 ad = (struct aac_disk *)bio->bio_driver_info;
1214
1215 if (sc->flags & AAC_FLAGS_RAW_IO) {
1216 struct aac_raw_io *raw;
1217 raw = (struct aac_raw_io *)&fib->data[0];
1218 fib->Header.Command = RawIo;
1219 raw->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE;
1220 raw->ByteCount = bp->b_bcount;
1221 raw->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1222 raw->BpTotal = 0;
1223 raw->BpComplete = 0;
1224 fib->Header.Size += sizeof(struct aac_raw_io);
1225 cm->cm_sgtable = (struct aac_sg_table *)&raw->SgMapRaw;
1226 if (bp->b_cmd == BUF_CMD_READ) {
1227 raw->Flags = 1;
1228 cm->cm_flags |= AAC_CMD_DATAIN;
1229 } else {
1230 raw->Flags = 0;
1231 cm->cm_flags |= AAC_CMD_DATAOUT;
1232 }
1233 } else if ((sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
1234 fib->Header.Command = ContainerCommand;
1235 if (bp->b_cmd == BUF_CMD_READ) {
1236 struct aac_blockread *br;
1237 br = (struct aac_blockread *)&fib->data[0];
1238 br->Command = VM_CtBlockRead;
1239 br->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1240 br->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE;
1241 br->ByteCount = bp->b_bcount;
1242 fib->Header.Size += sizeof(struct aac_blockread);
1243 cm->cm_sgtable = &br->SgMap;
1244 cm->cm_flags |= AAC_CMD_DATAIN;
1245 } else {
1246 struct aac_blockwrite *bw;
1247 bw = (struct aac_blockwrite *)&fib->data[0];
1248 bw->Command = VM_CtBlockWrite;
1249 bw->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1250 bw->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE;
1251 bw->ByteCount = bp->b_bcount;
1252 bw->Stable = CUNSTABLE;
1253 fib->Header.Size += sizeof(struct aac_blockwrite);
1254 cm->cm_flags |= AAC_CMD_DATAOUT;
1255 cm->cm_sgtable = &bw->SgMap;
1256 }
1257 } else {
1258 fib->Header.Command = ContainerCommand64;
1259 if (bp->b_cmd == BUF_CMD_READ) {
1260 struct aac_blockread64 *br;
1261 br = (struct aac_blockread64 *)&fib->data[0];
1262 br->Command = VM_CtHostRead64;
1263 br->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1264 br->SectorCount = bp->b_bcount / AAC_BLOCK_SIZE;
1265 br->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE;
1266 br->Pad = 0;
1267 br->Flags = 0;
1268 fib->Header.Size += sizeof(struct aac_blockread64);
1269 cm->cm_flags |= AAC_CMD_DATAIN;
1270 cm->cm_sgtable = (struct aac_sg_table *)&br->SgMap64;
1271 } else {
1272 struct aac_blockwrite64 *bw;
1273 bw = (struct aac_blockwrite64 *)&fib->data[0];
1274 bw->Command = VM_CtHostWrite64;
1275 bw->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1276 bw->SectorCount = bp->b_bcount / AAC_BLOCK_SIZE;
1277 bw->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE;
1278 bw->Pad = 0;
1279 bw->Flags = 0;
1280 fib->Header.Size += sizeof(struct aac_blockwrite64);
1281 cm->cm_flags |= AAC_CMD_DATAOUT;
1282 cm->cm_sgtable = (struct aac_sg_table *)&bw->SgMap64;
1283 }
1284 }
1285
1286 *cmp = cm;
1287 return(0);
1288
1289 fail:
1290 if (bio != NULL)
1291 aac_enqueue_bio(sc, bio);
1292 if (cm != NULL)
1293 aac_release_command(cm);
1294 return(ENOMEM);
1295 }
1296
1297 /*
1298 * Handle a bio-instigated command that has been completed.
1299 */
1300 static void
1301 aac_bio_complete(struct aac_command *cm)
1302 {
1303 struct aac_blockread_response *brr;
1304 struct aac_blockwrite_response *bwr;
1305 struct bio *bio;
1306 struct buf *bp;
1307 const char *code;
1308 AAC_FSAStatus status;
1309
1310 /* fetch relevant status and then release the command */
1311 bio = (struct bio *)cm->cm_private;
1312 bp = bio->bio_buf;
1313 if (bp->b_cmd == BUF_CMD_READ) {
1314 brr = (struct aac_blockread_response *)&cm->cm_fib->data[0];
1315 status = brr->Status;
1316 } else {
1317 bwr = (struct aac_blockwrite_response *)&cm->cm_fib->data[0];
1318 status = bwr->Status;
1319 }
1320 aac_release_command(cm);
1321
1322 /* fix up the bio based on status */
1323 if (status == ST_OK) {
1324 bp->b_resid = 0;
1325 code = NULL;
1326 } else {
1327 bp->b_error = EIO;
1328 bp->b_flags |= B_ERROR;
1329 }
1330 aac_biodone(bio, code);
1331 }
1332
1333 /*
1334 * Submit a command to the controller, return when it completes.
1335 * XXX This is very dangerous! If the card has gone out to lunch, we could
1336 * be stuck here forever. At the same time, signals are not caught
1337 * because there is a risk that a signal could wakeup the sleep before
1338 * the card has a chance to complete the command. Since there is no way
1339 * to cancel a command that is in progress, we can't protect against the
1340 * card completing a command late and spamming the command and data
1341 * memory. So, we are held hostage until the command completes.
1342 */
1343 static int
1344 aac_wait_command(struct aac_command *cm)
1345 {
1346 struct aac_softc *sc;
1347 int error;
1348
1349 sc = cm->cm_sc;
1350 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1351
1352 /* Put the command on the ready queue and get things going */
1353 aac_enqueue_ready(cm);
1354 aac_startio(sc);
1355 error = lksleep(cm, &sc->aac_io_lock, 0, "aacwait", 0);
1356 return(error);
1357 }
1358
1359 /*
1360 *Command Buffer Management
1361 */
1362
1363 /*
1364 * Allocate a command.
1365 */
1366 int
1367 aac_alloc_command(struct aac_softc *sc, struct aac_command **cmp)
1368 {
1369 struct aac_command *cm;
1370
1371 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1372
1373 if ((cm = aac_dequeue_free(sc)) == NULL) {
1374 if (sc->total_fibs < sc->aac_max_fibs) {
1375 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
1376 sc->aifflags |= AAC_AIFFLAGS_ALLOCFIBS;
1377 lockmgr(&sc->aac_io_lock, LK_RELEASE);
1378 wakeup(sc->aifthread);
1379 }
1380 return (EBUSY);
1381 }
1382
1383 *cmp = cm;
1384 return(0);
1385 }
1386
1387 /*
1388 * Release a command back to the freelist.
1389 */
1390 void
1391 aac_release_command(struct aac_command *cm)
1392 {
1393 struct aac_event *event;
1394 struct aac_softc *sc;
1395
1396 sc = cm->cm_sc;
1397 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1398
1399 /* (re)initialize the command/FIB */
1400 cm->cm_sgtable = NULL;
1401 cm->cm_flags = 0;
1402 cm->cm_complete = NULL;
1403 cm->cm_private = NULL;
1404 cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE;
1405 cm->cm_fib->Header.XferState = AAC_FIBSTATE_EMPTY;
1406 cm->cm_fib->Header.StructType = AAC_FIBTYPE_TFIB;
1407 cm->cm_fib->Header.Flags = 0;
1408 cm->cm_fib->Header.SenderSize = cm->cm_sc->aac_max_fib_size;
1409
1410 /*
1411 * These are duplicated in aac_start to cover the case where an
1412 * intermediate stage may have destroyed them. They're left
1413 * initialized here for debugging purposes only.
1414 */
1415 cm->cm_fib->Header.ReceiverFibAddress = (u_int32_t)cm->cm_fibphys;
1416 cm->cm_fib->Header.SenderData = 0;
1417
1418 aac_enqueue_free(cm);
1419
1420 if ((event = TAILQ_FIRST(&sc->aac_ev_cmfree)) != NULL) {
1421 TAILQ_REMOVE(&sc->aac_ev_cmfree, event, ev_links);
1422 event->ev_callback(sc, event, event->ev_arg);
1423 }
1424 }
1425
1426 /*
1427 * Map helper for command/FIB allocation.
1428 */
1429 static void
1430 aac_map_command_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1431 {
1432 uint64_t *fibphys;
1433
1434 fibphys = (uint64_t *)arg;
1435
1436 *fibphys = segs[0].ds_addr;
1437 }
1438
1439 /*
1440 * Allocate and initialize commands/FIBs for this adapter.
1441 */
1442 static int
1443 aac_alloc_commands(struct aac_softc *sc)
1444 {
1445 struct aac_command *cm;
1446 struct aac_fibmap *fm;
1447 uint64_t fibphys;
1448 int i, error;
1449
1450 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1451
1452 if (sc->total_fibs + sc->aac_max_fibs_alloc > sc->aac_max_fibs)
1453 return (ENOMEM);
1454
1455 fm = kmalloc(sizeof(struct aac_fibmap), M_AACBUF, M_INTWAIT | M_ZERO);
1456
1457 /* allocate the FIBs in DMAable memory and load them */
1458 if (bus_dmamem_alloc(sc->aac_fib_dmat, (void **)&fm->aac_fibs,
1459 BUS_DMA_NOWAIT, &fm->aac_fibmap)) {
1460 device_printf(sc->aac_dev,
1461 "Not enough contiguous memory available.\n");
1462 kfree(fm, M_AACBUF);
1463 return (ENOMEM);
1464 }
1465
1466 /* Ignore errors since this doesn't bounce */
1467 (void)bus_dmamap_load(sc->aac_fib_dmat, fm->aac_fibmap, fm->aac_fibs,
1468 sc->aac_max_fibs_alloc * sc->aac_max_fib_size,
1469 aac_map_command_helper, &fibphys, 0);
1470
1471 /* initialize constant fields in the command structure */
1472 bzero(fm->aac_fibs, sc->aac_max_fibs_alloc * sc->aac_max_fib_size);
1473 for (i = 0; i < sc->aac_max_fibs_alloc; i++) {
1474 cm = sc->aac_commands + sc->total_fibs;
1475 fm->aac_commands = cm;
1476 cm->cm_sc = sc;
1477 cm->cm_fib = (struct aac_fib *)
1478 ((u_int8_t *)fm->aac_fibs + i*sc->aac_max_fib_size);
1479 cm->cm_fibphys = fibphys + i*sc->aac_max_fib_size;
1480 cm->cm_index = sc->total_fibs;
1481
1482 if ((error = bus_dmamap_create(sc->aac_buffer_dmat, 0,
1483 &cm->cm_datamap)) != 0)
1484 break;
1485 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
1486 aac_release_command(cm);
1487 sc->total_fibs++;
1488 lockmgr(&sc->aac_io_lock, LK_RELEASE);
1489 }
1490
1491 if (i > 0) {
1492 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
1493 TAILQ_INSERT_TAIL(&sc->aac_fibmap_tqh, fm, fm_link);
1494 fwprintf(sc, HBA_FLAGS_DBG_COMM_B, "total_fibs= %d\n", sc->total_fibs);
1495 lockmgr(&sc->aac_io_lock, LK_RELEASE);
1496 return (0);
1497 }
1498
1499 bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap);
1500 bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap);
1501 kfree(fm, M_AACBUF);
1502 return (ENOMEM);
1503 }
1504
1505 /*
1506 * Free FIBs owned by this adapter.
1507 */
1508 static void
1509 aac_free_commands(struct aac_softc *sc)
1510 {
1511 struct aac_fibmap *fm;
1512 struct aac_command *cm;
1513 int i;
1514
1515 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1516
1517 while ((fm = TAILQ_FIRST(&sc->aac_fibmap_tqh)) != NULL) {
1518
1519 TAILQ_REMOVE(&sc->aac_fibmap_tqh, fm, fm_link);
1520 /*
1521 * We check against total_fibs to handle partially
1522 * allocated blocks.
1523 */
1524 for (i = 0; i < sc->aac_max_fibs_alloc && sc->total_fibs--; i++) {
1525 cm = fm->aac_commands + i;
1526 bus_dmamap_destroy(sc->aac_buffer_dmat, cm->cm_datamap);
1527 }
1528 bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap);
1529 bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap);
1530 kfree(fm, M_AACBUF);
1531 }
1532 }
1533
1534 /*
1535 * Command-mapping helper function - populate this command's s/g table.
1536 */
1537 static void
1538 aac_map_command_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1539 {
1540 struct aac_softc *sc;
1541 struct aac_command *cm;
1542 struct aac_fib *fib;
1543 int i;
1544
1545 cm = (struct aac_command *)arg;
1546 sc = cm->cm_sc;
1547 fib = cm->cm_fib;
1548 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1549
1550 /* copy into the FIB */
1551 if (cm->cm_sgtable != NULL) {
1552 if (fib->Header.Command == RawIo) {
1553 struct aac_sg_tableraw *sg;
1554 sg = (struct aac_sg_tableraw *)cm->cm_sgtable;
1555 sg->SgCount = nseg;
1556 for (i = 0; i < nseg; i++) {
1557 sg->SgEntryRaw[i].SgAddress = segs[i].ds_addr;
1558 sg->SgEntryRaw[i].SgByteCount = segs[i].ds_len;
1559 sg->SgEntryRaw[i].Next = 0;
1560 sg->SgEntryRaw[i].Prev = 0;
1561 sg->SgEntryRaw[i].Flags = 0;
1562 }
1563 /* update the FIB size for the s/g count */
1564 fib->Header.Size += nseg*sizeof(struct aac_sg_entryraw);
1565 } else if ((cm->cm_sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
1566 struct aac_sg_table *sg;
1567 sg = cm->cm_sgtable;
1568 sg->SgCount = nseg;
1569 for (i = 0; i < nseg; i++) {
1570 sg->SgEntry[i].SgAddress = segs[i].ds_addr;
1571 sg->SgEntry[i].SgByteCount = segs[i].ds_len;
1572 }
1573 /* update the FIB size for the s/g count */
1574 fib->Header.Size += nseg*sizeof(struct aac_sg_entry);
1575 } else {
1576 struct aac_sg_table64 *sg;
1577 sg = (struct aac_sg_table64 *)cm->cm_sgtable;
1578 sg->SgCount = nseg;
1579 for (i = 0; i < nseg; i++) {
1580 sg->SgEntry64[i].SgAddress = segs[i].ds_addr;
1581 sg->SgEntry64[i].SgByteCount = segs[i].ds_len;
1582 }
1583 /* update the FIB size for the s/g count */
1584 fib->Header.Size += nseg*sizeof(struct aac_sg_entry64);
1585 }
1586 }
1587
1588 /* Fix up the address values in the FIB. Use the command array index
1589 * instead of a pointer since these fields are only 32 bits. Shift
1590 * the SenderFibAddress over to make room for the fast response bit
1591 * and for the AIF bit
1592 */
1593 cm->cm_fib->Header.SenderFibAddress = (cm->cm_index << 2);
1594 cm->cm_fib->Header.ReceiverFibAddress = (u_int32_t)cm->cm_fibphys;
1595
1596 /* save a pointer to the command for speedy reverse-lookup */
1597 cm->cm_fib->Header.SenderData = cm->cm_index;
1598
1599 if (cm->cm_flags & AAC_CMD_DATAIN)
1600 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1601 BUS_DMASYNC_PREREAD);
1602 if (cm->cm_flags & AAC_CMD_DATAOUT)
1603 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1604 BUS_DMASYNC_PREWRITE);
1605 cm->cm_flags |= AAC_CMD_MAPPED;
1606
1607 if (sc->flags & AAC_FLAGS_NEW_COMM) {
1608 int count = 10000000L;
1609 while (AAC_SEND_COMMAND(sc, cm) != 0) {
1610 if (--count == 0) {
1611 aac_unmap_command(cm);
1612 sc->flags |= AAC_QUEUE_FRZN;
1613 aac_requeue_ready(cm);
1614 }
1615 DELAY(5); /* wait 5 usec. */
1616 }
1617 } else {
1618 /* Put the FIB on the outbound queue */
1619 if (aac_enqueue_fib(sc, cm->cm_queue, cm) == EBUSY) {
1620 aac_unmap_command(cm);
1621 sc->flags |= AAC_QUEUE_FRZN;
1622 aac_requeue_ready(cm);
1623 }
1624 }
1625 }
1626
1627 /*
1628 * Unmap a command from controller-visible space.
1629 */
1630 static void
1631 aac_unmap_command(struct aac_command *cm)
1632 {
1633 struct aac_softc *sc;
1634
1635 sc = cm->cm_sc;
1636 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1637
1638 if (!(cm->cm_flags & AAC_CMD_MAPPED))
1639 return;
1640
1641 if (cm->cm_datalen != 0) {
1642 if (cm->cm_flags & AAC_CMD_DATAIN)
1643 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1644 BUS_DMASYNC_POSTREAD);
1645 if (cm->cm_flags & AAC_CMD_DATAOUT)
1646 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1647 BUS_DMASYNC_POSTWRITE);
1648
1649 bus_dmamap_unload(sc->aac_buffer_dmat, cm->cm_datamap);
1650 }
1651 cm->cm_flags &= ~AAC_CMD_MAPPED;
1652 }
1653
1654 /*
1655 * Hardware Interface
1656 */
1657
1658 /*
1659 * Initialize the adapter.
1660 */
1661 static void
1662 aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1663 {
1664 struct aac_softc *sc;
1665
1666 sc = (struct aac_softc *)arg;
1667 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1668
1669 sc->aac_common_busaddr = segs[0].ds_addr;
1670 }
1671
1672 static int
1673 aac_check_firmware(struct aac_softc *sc)
1674 {
1675 u_int32_t code, major, minor, options = 0, atu_size = 0;
1676 int rid, status;
1677 time_t then;
1678
1679 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1680 /*
1681 * Wait for the adapter to come ready.
1682 */
1683 then = time_uptime;
1684 do {
1685 code = AAC_GET_FWSTATUS(sc);
1686 if (code & AAC_SELF_TEST_FAILED) {
1687 device_printf(sc->aac_dev, "FATAL: selftest failed\n");
1688 return(ENXIO);
1689 }
1690 if (code & AAC_KERNEL_PANIC) {
1691 device_printf(sc->aac_dev,
1692 "FATAL: controller kernel panic");
1693 return(ENXIO);
1694 }
1695 if (time_uptime > (then + AAC_BOOT_TIMEOUT)) {
1696 device_printf(sc->aac_dev,
1697 "FATAL: controller not coming ready, "
1698 "status %x\n", code);
1699 return(ENXIO);
1700 }
1701 } while (!(code & AAC_UP_AND_RUNNING));
1702
1703 /*
1704 * Retrieve the firmware version numbers. Dell PERC2/QC cards with
1705 * firmware version 1.x are not compatible with this driver.
1706 */
1707 if (sc->flags & AAC_FLAGS_PERC2QC) {
1708 if (aac_sync_command(sc, AAC_MONKER_GETKERNVER, 0, 0, 0, 0,
1709 NULL)) {
1710 device_printf(sc->aac_dev,
1711 "Error reading firmware version\n");
1712 return (EIO);
1713 }
1714
1715 /* These numbers are stored as ASCII! */
1716 major = (AAC_GET_MAILBOX(sc, 1) & 0xff) - 0x30;
1717 minor = (AAC_GET_MAILBOX(sc, 2) & 0xff) - 0x30;
1718 if (major == 1) {
1719 device_printf(sc->aac_dev,
1720 "Firmware version %d.%d is not supported.\n",
1721 major, minor);
1722 return (EINVAL);
1723 }
1724 }
1725
1726 /*
1727 * Retrieve the capabilities/supported options word so we know what
1728 * work-arounds to enable. Some firmware revs don't support this
1729 * command.
1730 */
1731 if (aac_sync_command(sc, AAC_MONKER_GETINFO, 0, 0, 0, 0, &status)) {
1732 if (status != AAC_SRB_STS_INVALID_REQUEST) {
1733 device_printf(sc->aac_dev,
1734 "RequestAdapterInfo failed\n");
1735 return (EIO);
1736 }
1737 } else {
1738 options = AAC_GET_MAILBOX(sc, 1);
1739 atu_size = AAC_GET_MAILBOX(sc, 2);
1740 sc->supported_options = options;
1741
1742 if ((options & AAC_SUPPORTED_4GB_WINDOW) != 0 &&
1743 (sc->flags & AAC_FLAGS_NO4GB) == 0)
1744 sc->flags |= AAC_FLAGS_4GB_WINDOW;
1745 if (options & AAC_SUPPORTED_NONDASD)
1746 sc->flags |= AAC_FLAGS_ENABLE_CAM;
1747 if ((options & AAC_SUPPORTED_SGMAP_HOST64) != 0
1748 && (sizeof(bus_addr_t) > 4)) {
1749 device_printf(sc->aac_dev,
1750 "Enabling 64-bit address support\n");
1751 sc->flags |= AAC_FLAGS_SG_64BIT;
1752 }
1753 if ((options & AAC_SUPPORTED_NEW_COMM)
1754 && sc->aac_if->aif_send_command)
1755 sc->flags |= AAC_FLAGS_NEW_COMM;
1756 if (options & AAC_SUPPORTED_64BIT_ARRAYSIZE)
1757 sc->flags |= AAC_FLAGS_ARRAY_64BIT;
1758 }
1759
1760 /* Check for broken hardware that does a lower number of commands */
1761 sc->aac_max_fibs = (sc->flags & AAC_FLAGS_256FIBS ? 256:512);
1762
1763 /* Remap mem. resource, if required */
1764 if ((sc->flags & AAC_FLAGS_NEW_COMM) &&
1765 atu_size > rman_get_size(sc->aac_regs_res1)) {
1766 rid = rman_get_rid(sc->aac_regs_res1);
1767 bus_release_resource(sc->aac_dev, SYS_RES_MEMORY, rid,
1768 sc->aac_regs_res1);
1769 sc->aac_regs_res1 = bus_alloc_resource(sc->aac_dev,
1770 SYS_RES_MEMORY, &rid, 0ul, ~0ul, atu_size, RF_ACTIVE);
1771 if (sc->aac_regs_res1 == NULL) {
1772 sc->aac_regs_res1 = bus_alloc_resource_any(
1773 sc->aac_dev, SYS_RES_MEMORY, &rid, RF_ACTIVE);
1774 if (sc->aac_regs_res1 == NULL) {
1775 device_printf(sc->aac_dev,
1776 "couldn't allocate register window\n");
1777 return (ENXIO);
1778 }
1779 sc->flags &= ~AAC_FLAGS_NEW_COMM;
1780 }
1781 sc->aac_btag1 = rman_get_bustag(sc->aac_regs_res1);
1782 sc->aac_bhandle1 = rman_get_bushandle(sc->aac_regs_res1);
1783
1784 if (sc->aac_hwif == AAC_HWIF_NARK) {
1785 sc->aac_regs_res0 = sc->aac_regs_res1;
1786 sc->aac_btag0 = sc->aac_btag1;
1787 sc->aac_bhandle0 = sc->aac_bhandle1;
1788 }
1789 }
1790
1791 /* Read preferred settings */
1792 sc->aac_max_fib_size = sizeof(struct aac_fib);
1793 sc->aac_max_sectors = 128; /* 64KB */
1794 if (sc->flags & AAC_FLAGS_SG_64BIT)
1795 sc->aac_sg_tablesize = (AAC_FIB_DATASIZE
1796 - sizeof(struct aac_blockwrite64))
1797 / sizeof(struct aac_sg_entry64);
1798 else
1799 sc->aac_sg_tablesize = (AAC_FIB_DATASIZE
1800 - sizeof(struct aac_blockwrite))
1801 / sizeof(struct aac_sg_entry);
1802
1803 if (!aac_sync_command(sc, AAC_MONKER_GETCOMMPREF, 0, 0, 0, 0, NULL)) {
1804 options = AAC_GET_MAILBOX(sc, 1);
1805 sc->aac_max_fib_size = (options & 0xFFFF);
1806 sc->aac_max_sectors = (options >> 16) << 1;
1807 options = AAC_GET_MAILBOX(sc, 2);
1808 sc->aac_sg_tablesize = (options >> 16);
1809 options = AAC_GET_MAILBOX(sc, 3);
1810 sc->aac_max_fibs = (options & 0xFFFF);
1811 }
1812 if (sc->aac_max_fib_size > PAGE_SIZE)
1813 sc->aac_max_fib_size = PAGE_SIZE;
1814 sc->aac_max_fibs_alloc = PAGE_SIZE / sc->aac_max_fib_size;
1815
1816 if (sc->aac_max_fib_size > sizeof(struct aac_fib)) {
1817 sc->flags |= AAC_FLAGS_RAW_IO;
1818 device_printf(sc->aac_dev, "Enable Raw I/O\n");
1819 }
1820 if ((sc->flags & AAC_FLAGS_RAW_IO) &&
1821 (sc->flags & AAC_FLAGS_ARRAY_64BIT)) {
1822 sc->flags |= AAC_FLAGS_LBA_64BIT;
1823 device_printf(sc->aac_dev, "Enable 64-bit array\n");
1824 }
1825
1826 return (0);
1827 }
1828
1829 static int
1830 aac_init(struct aac_softc *sc)
1831 {
1832 struct aac_adapter_init *ip;
1833 u_int32_t qoffset;
1834 int error;
1835
1836 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1837
1838 /*
1839 * Fill in the init structure. This tells the adapter about the
1840 * physical location of various important shared data structures.
1841 */
1842 ip = &sc->aac_common->ac_init;
1843 ip->InitStructRevision = AAC_INIT_STRUCT_REVISION;
1844 if (sc->aac_max_fib_size > sizeof(struct aac_fib)) {
1845 ip->InitStructRevision = AAC_INIT_STRUCT_REVISION_4;
1846 sc->flags |= AAC_FLAGS_RAW_IO;
1847 }
1848 ip->MiniPortRevision = AAC_INIT_STRUCT_MINIPORT_REVISION;
1849
1850 ip->AdapterFibsPhysicalAddress = sc->aac_common_busaddr +
1851 offsetof(struct aac_common, ac_fibs);
1852 ip->AdapterFibsVirtualAddress = 0;
1853 ip->AdapterFibsSize = AAC_ADAPTER_FIBS * sizeof(struct aac_fib);
1854 ip->AdapterFibAlign = sizeof(struct aac_fib);
1855
1856 ip->PrintfBufferAddress = sc->aac_common_busaddr +
1857 offsetof(struct aac_common, ac_printf);
1858 ip->PrintfBufferSize = AAC_PRINTF_BUFSIZE;
1859
1860 /*
1861 * The adapter assumes that pages are 4K in size, except on some
1862 * broken firmware versions that do the page->byte conversion twice,
1863 * therefore 'assuming' that this value is in 16MB units (2^24).
1864 * Round up since the granularity is so high.
1865 */
1866 ip->HostPhysMemPages = ctob(physmem) / AAC_PAGE_SIZE;
1867 if (sc->flags & AAC_FLAGS_BROKEN_MEMMAP) {
1868 ip->HostPhysMemPages =
1869 (ip->HostPhysMemPages + AAC_PAGE_SIZE) / AAC_PAGE_SIZE;
1870 }
1871 ip->HostElapsedSeconds = time_uptime; /* reset later if invalid */
1872
1873 ip->InitFlags = 0;
1874 if (sc->flags & AAC_FLAGS_NEW_COMM) {
1875 ip->InitFlags |= AAC_INITFLAGS_NEW_COMM_SUPPORTED;
1876 device_printf(sc->aac_dev, "New comm. interface enabled\n");
1877 }
1878
1879 ip->MaxIoCommands = sc->aac_max_fibs;
1880 ip->MaxIoSize = sc->aac_max_sectors << 9;
1881 ip->MaxFibSize = sc->aac_max_fib_size;
1882
1883 /*
1884 * Initialize FIB queues. Note that it appears that the layout of the
1885 * indexes and the segmentation of the entries may be mandated by the
1886 * adapter, which is only told about the base of the queue index fields.
1887 *
1888 * The initial values of the indices are assumed to inform the adapter
1889 * of the sizes of the respective queues, and theoretically it could
1890 * work out the entire layout of the queue structures from this. We
1891 * take the easy route and just lay this area out like everyone else
1892 * does.
1893 *
1894 * The Linux driver uses a much more complex scheme whereby several
1895 * header records are kept for each queue. We use a couple of generic
1896 * list manipulation functions which 'know' the size of each list by
1897 * virtue of a table.
1898 */
1899 qoffset = offsetof(struct aac_common, ac_qbuf) + AAC_QUEUE_ALIGN;
1900 qoffset &= ~(AAC_QUEUE_ALIGN - 1);
1901 sc->aac_queues =
1902 (struct aac_queue_table *)((uintptr_t)sc->aac_common + qoffset);
1903 ip->CommHeaderAddress = sc->aac_common_busaddr + qoffset;
1904
1905 sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1906 AAC_HOST_NORM_CMD_ENTRIES;
1907 sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1908 AAC_HOST_NORM_CMD_ENTRIES;
1909 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1910 AAC_HOST_HIGH_CMD_ENTRIES;
1911 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1912 AAC_HOST_HIGH_CMD_ENTRIES;
1913 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1914 AAC_ADAP_NORM_CMD_ENTRIES;
1915 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1916 AAC_ADAP_NORM_CMD_ENTRIES;
1917 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1918 AAC_ADAP_HIGH_CMD_ENTRIES;
1919 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1920 AAC_ADAP_HIGH_CMD_ENTRIES;
1921 sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1922 AAC_HOST_NORM_RESP_ENTRIES;
1923 sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1924 AAC_HOST_NORM_RESP_ENTRIES;
1925 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1926 AAC_HOST_HIGH_RESP_ENTRIES;
1927 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1928 AAC_HOST_HIGH_RESP_ENTRIES;
1929 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1930 AAC_ADAP_NORM_RESP_ENTRIES;
1931 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1932 AAC_ADAP_NORM_RESP_ENTRIES;
1933 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1934 AAC_ADAP_HIGH_RESP_ENTRIES;
1935 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1936 AAC_ADAP_HIGH_RESP_ENTRIES;
1937 sc->aac_qentries[AAC_HOST_NORM_CMD_QUEUE] =
1938 &sc->aac_queues->qt_HostNormCmdQueue[0];
1939 sc->aac_qentries[AAC_HOST_HIGH_CMD_QUEUE] =
1940 &sc->aac_queues->qt_HostHighCmdQueue[0];
1941 sc->aac_qentries[AAC_ADAP_NORM_CMD_QUEUE] =
1942 &sc->aac_queues->qt_AdapNormCmdQueue[0];
1943 sc->aac_qentries[AAC_ADAP_HIGH_CMD_QUEUE] =
1944 &sc->aac_queues->qt_AdapHighCmdQueue[0];
1945 sc->aac_qentries[AAC_HOST_NORM_RESP_QUEUE] =
1946 &sc->aac_queues->qt_HostNormRespQueue[0];
1947 sc->aac_qentries[AAC_HOST_HIGH_RESP_QUEUE] =
1948 &sc->aac_queues->qt_HostHighRespQueue[0];
1949 sc->aac_qentries[AAC_ADAP_NORM_RESP_QUEUE] =
1950 &sc->aac_queues->qt_AdapNormRespQueue[0];
1951 sc->aac_qentries[AAC_ADAP_HIGH_RESP_QUEUE] =
1952 &sc->aac_queues->qt_AdapHighRespQueue[0];
1953
1954 /*
1955 * Do controller-type-specific initialisation
1956 */
1957 switch (sc->aac_hwif) {
1958 case AAC_HWIF_I960RX:
1959 AAC_MEM0_SETREG4(sc, AAC_RX_ODBR, ~0);
1960 break;
1961 case AAC_HWIF_RKT:
1962 AAC_MEM0_SETREG4(sc, AAC_RKT_ODBR, ~0);
1963 break;
1964 default:
1965 break;
1966 }
1967
1968 /*
1969 * Give the init structure to the controller.
1970 */
1971 if (aac_sync_command(sc, AAC_MONKER_INITSTRUCT,
1972 sc->aac_common_busaddr +
1973 offsetof(struct aac_common, ac_init), 0, 0, 0,
1974 NULL)) {
1975 device_printf(sc->aac_dev,
1976 "error establishing init structure\n");
1977 error = EIO;
1978 goto out;
1979 }
1980
1981 error = 0;
1982 out:
1983 return(error);
1984 }
1985
1986 static int
1987 aac_setup_intr(struct aac_softc *sc)
1988 {
1989
1990 if (sc->flags & AAC_FLAGS_NEW_COMM) {
1991 if (bus_setup_intr(sc->aac_dev, sc->aac_irq,
1992 INTR_MPSAFE,
1993 aac_new_intr, sc, &sc->aac_intr, NULL)) {
1994 device_printf(sc->aac_dev, "can't set up interrupt\n");
1995 return (EINVAL);
1996 }
1997 } else {
1998 if (bus_setup_intr(sc->aac_dev, sc->aac_irq,
1999 0, aac_filter,
2000 sc, &sc->aac_intr, NULL)) {
2001 device_printf(sc->aac_dev,
2002 "can't set up interrupt filter\n");
2003 return (EINVAL);
2004 }
2005 }
2006 return (0);
2007 }
2008
2009 /*
2010 * Send a synchronous command to the controller and wait for a result.
2011 * Indicate if the controller completed the command with an error status.
2012 */
2013 static int
2014 aac_sync_command(struct aac_softc *sc, u_int32_t command,
2015 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3,
2016 u_int32_t *sp)
2017 {
2018 time_t then;
2019 u_int32_t status;
2020
2021 if (sp != NULL)
2022 *sp = 0; /* avoid gcc warnings */
2023 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2024
2025 /* populate the mailbox */
2026 AAC_SET_MAILBOX(sc, command, arg0, arg1, arg2, arg3);
2027
2028 /* ensure the sync command doorbell flag is cleared */
2029 AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND);
2030
2031 /* then set it to signal the adapter */
2032 AAC_QNOTIFY(sc, AAC_DB_SYNC_COMMAND);
2033
2034 /* spin waiting for the command to complete */
2035 then = time_uptime;
2036 do {
2037 if (time_uptime > (then + AAC_IMMEDIATE_TIMEOUT)) {
2038 fwprintf(sc, HBA_FLAGS_DBG_ERROR_B, "timed out");
2039 return(EIO);
2040 }
2041 } while (!(AAC_GET_ISTATUS(sc) & AAC_DB_SYNC_COMMAND));
2042
2043 /* clear the completion flag */
2044 AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND);
2045
2046 /* get the command status */
2047 status = AAC_GET_MAILBOX(sc, 0);
2048 if (sp != NULL)
2049 *sp = status;
2050
2051 if (status != AAC_SRB_STS_SUCCESS)
2052 return (-1);
2053 return(0);
2054 }
2055
2056 int
2057 aac_sync_fib(struct aac_softc *sc, u_int32_t command, u_int32_t xferstate,
2058 struct aac_fib *fib, u_int16_t datasize)
2059 {
2060 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2061 #if 0 /* XXX swildner */
2062 KKASSERT(lockstatus(&sc->aac_io_lock, curthread) != 0);
2063 #endif
2064
2065 if (datasize > AAC_FIB_DATASIZE)
2066 return(EINVAL);
2067
2068 /*
2069 * Set up the sync FIB
2070 */
2071 fib->Header.XferState = AAC_FIBSTATE_HOSTOWNED |
2072 AAC_FIBSTATE_INITIALISED |
2073 AAC_FIBSTATE_EMPTY;
2074 fib->Header.XferState |= xferstate;
2075 fib->Header.Command = command;
2076 fib->Header.StructType = AAC_FIBTYPE_TFIB;
2077 fib->Header.Size = sizeof(struct aac_fib_header) + datasize;
2078 fib->Header.SenderSize = sizeof(struct aac_fib);
2079 fib->Header.SenderFibAddress = 0; /* Not needed */
2080 fib->Header.ReceiverFibAddress = sc->aac_common_busaddr +
2081 offsetof(struct aac_common,
2082 ac_sync_fib);
2083
2084 /*
2085 * Give the FIB to the controller, wait for a response.
2086 */
2087 if (aac_sync_command(sc, AAC_MONKER_SYNCFIB,
2088 fib->Header.ReceiverFibAddress, 0, 0, 0, NULL)) {
2089 fwprintf(sc, HBA_FLAGS_DBG_ERROR_B, "IO error");
2090 return(EIO);
2091 }
2092
2093 return (0);
2094 }
2095
2096 /*
2097 * Adapter-space FIB queue manipulation
2098 *
2099 * Note that the queue implementation here is a little funky; neither the PI or
2100 * CI will ever be zero. This behaviour is a controller feature.
2101 */
2102 static const struct {
2103 int size;
2104 int notify;
2105 } aac_qinfo[] = {
2106 {AAC_HOST_NORM_CMD_ENTRIES, AAC_DB_COMMAND_NOT_FULL},
2107 {AAC_HOST_HIGH_CMD_ENTRIES, 0},
2108 {AAC_ADAP_NORM_CMD_ENTRIES, AAC_DB_COMMAND_READY},
2109 {AAC_ADAP_HIGH_CMD_ENTRIES, 0},
2110 {AAC_HOST_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_NOT_FULL},
2111 {AAC_HOST_HIGH_RESP_ENTRIES, 0},
2112 {AAC_ADAP_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_READY},
2113 {AAC_ADAP_HIGH_RESP_ENTRIES, 0}
2114 };
2115
2116 /*
2117 * Atomically insert an entry into the nominated queue, returns 0 on success or
2118 * EBUSY if the queue is full.
2119 *
2120 * Note: it would be more efficient to defer notifying the controller in
2121 * the case where we may be inserting several entries in rapid succession,
2122 * but implementing this usefully may be difficult (it would involve a
2123 * separate queue/notify interface).
2124 */
2125 static int
2126 aac_enqueue_fib(struct aac_softc *sc, int queue, struct aac_command *cm)
2127 {
2128 u_int32_t pi, ci;
2129 int error;
2130 u_int32_t fib_size;
2131 u_int32_t fib_addr;
2132
2133 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2134
2135 fib_size = cm->cm_fib->Header.Size;
2136 fib_addr = cm->cm_fib->Header.ReceiverFibAddress;
2137
2138 /* get the producer/consumer indices */
2139 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
2140 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
2141
2142 /* wrap the queue? */
2143 if (pi >= aac_qinfo[queue].size)
2144 pi = 0;
2145
2146 /* check for queue full */
2147 if ((pi + 1) == ci) {
2148 error = EBUSY;
2149 goto out;
2150 }
2151
2152 /*
2153 * To avoid a race with its completion interrupt, place this command on
2154 * the busy queue prior to advertising it to the controller.
2155 */
2156 aac_enqueue_busy(cm);
2157
2158 /* populate queue entry */
2159 (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size;
2160 (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr;
2161
2162 /* update producer index */
2163 sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;
2164
2165 /* notify the adapter if we know how */
2166 if (aac_qinfo[queue].notify != 0)
2167 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
2168
2169 error = 0;
2170
2171 out:
2172 return(error);
2173 }
2174
2175 /*
2176 * Atomically remove one entry from the nominated queue, returns 0 on
2177 * success or ENOENT if the queue is empty.
2178 */
2179 static int
2180 aac_dequeue_fib(struct aac_softc *sc, int queue, u_int32_t *fib_size,
2181 struct aac_fib **fib_addr)
2182 {
2183 u_int32_t pi, ci;
2184 u_int32_t fib_index;
2185 int error;
2186 int notify;
2187
2188 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2189
2190 /* get the producer/consumer indices */
2191 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
2192 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
2193
2194 /* check for queue empty */
2195 if (ci == pi) {
2196 error = ENOENT;
2197 goto out;
2198 }
2199
2200 /* wrap the pi so the following test works */
2201 if (pi >= aac_qinfo[queue].size)
2202 pi = 0;
2203
2204 notify = 0;
2205 if (ci == pi + 1)
2206 notify++;
2207
2208 /* wrap the queue? */
2209 if (ci >= aac_qinfo[queue].size)
2210 ci = 0;
2211
2212 /* fetch the entry */
2213 *fib_size = (sc->aac_qentries[queue] + ci)->aq_fib_size;
2214
2215 switch (queue) {
2216 case AAC_HOST_NORM_CMD_QUEUE:
2217 case AAC_HOST_HIGH_CMD_QUEUE:
2218 /*
2219 * The aq_fib_addr is only 32 bits wide so it can't be counted
2220 * on to hold an address. For AIF's, the adapter assumes
2221 * that it's giving us an address into the array of AIF fibs.
2222 * Therefore, we have to convert it to an index.
2223 */
2224 fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr /
2225 sizeof(struct aac_fib);
2226 *fib_addr = &sc->aac_common->ac_fibs[fib_index];
2227 break;
2228
2229 case AAC_HOST_NORM_RESP_QUEUE:
2230 case AAC_HOST_HIGH_RESP_QUEUE:
2231 {
2232 struct aac_command *cm;
2233
2234 /*
2235 * As above, an index is used instead of an actual address.
2236 * Gotta shift the index to account for the fast response
2237 * bit. No other correction is needed since this value was
2238 * originally provided by the driver via the SenderFibAddress
2239 * field.
2240 */
2241 fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr;
2242 cm = sc->aac_commands + (fib_index >> 2);
2243 *fib_addr = cm->cm_fib;
2244
2245 /*
2246 * Is this a fast response? If it is, update the fib fields in
2247 * local memory since the whole fib isn't DMA'd back up.
2248 */
2249 if (fib_index & 0x01) {
2250 (*fib_addr)->Header.XferState |= AAC_FIBSTATE_DONEADAP;
2251 *((u_int32_t*)((*fib_addr)->data)) = AAC_ERROR_NORMAL;
2252 }
2253 break;
2254 }
2255 default:
2256 panic("Invalid queue in aac_dequeue_fib()");
2257 break;
2258 }
2259
2260 /* update consumer index */
2261 sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX] = ci + 1;
2262
2263 /* if we have made the queue un-full, notify the adapter */
2264 if (notify && (aac_qinfo[queue].notify != 0))
2265 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
2266 error = 0;
2267
2268 out:
2269 return(error);
2270 }
2271
2272 /*
2273 * Put our response to an Adapter Initialed Fib on the response queue
2274 */
2275 static int
2276 aac_enqueue_response(struct aac_softc *sc, int queue, struct aac_fib *fib)
2277 {
2278 u_int32_t pi, ci;
2279 int error;
2280 u_int32_t fib_size;
2281 u_int32_t fib_addr;
2282
2283 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2284
2285 /* Tell the adapter where the FIB is */
2286 fib_size = fib->Header.Size;
2287 fib_addr = fib->Header.SenderFibAddress;
2288 fib->Header.ReceiverFibAddress = fib_addr;
2289
2290 /* get the producer/consumer indices */
2291 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
2292 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
2293
2294 /* wrap the queue? */
2295 if (pi >= aac_qinfo[queue].size)
2296 pi = 0;
2297
2298 /* check for queue full */
2299 if ((pi + 1) == ci) {
2300 error = EBUSY;
2301 goto out;
2302 }
2303
2304 /* populate queue entry */
2305 (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size;
2306 (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr;
2307
2308 /* update producer index */
2309 sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;
2310
2311 /* notify the adapter if we know how */
2312 if (aac_qinfo[queue].notify != 0)
2313 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
2314
2315 error = 0;
2316
2317 out:
2318 return(error);
2319 }
2320
2321 /*
2322 * Check for commands that have been outstanding for a suspiciously long time,
2323 * and complain about them.
2324 */
2325 static void
2326 aac_timeout(struct aac_softc *sc)
2327 {
2328 struct aac_command *cm;
2329 time_t deadline;
2330 int timedout, code;
2331
2332 /*
2333 * Traverse the busy command list, bitch about late commands once
2334 * only.
2335 */
2336 timedout = 0;
2337 deadline = time_uptime - AAC_CMD_TIMEOUT;
2338 TAILQ_FOREACH(cm, &sc->aac_busy, cm_link) {
2339 if ((cm->cm_timestamp < deadline)
2340 && !(cm->cm_flags & AAC_CMD_TIMEDOUT)) {
2341 cm->cm_flags |= AAC_CMD_TIMEDOUT;
2342 device_printf(sc->aac_dev,
2343 "COMMAND %p (TYPE %d) TIMEOUT AFTER %d SECONDS\n",
2344 cm, cm->cm_fib->Header.Command,
2345 (int)(time_uptime-cm->cm_timestamp));
2346 AAC_PRINT_FIB(sc, cm->cm_fib);
2347 timedout++;
2348 }
2349 }
2350
2351 if (timedout) {
2352 code = AAC_GET_FWSTATUS(sc);
2353 if (code != AAC_UP_AND_RUNNING) {
2354 device_printf(sc->aac_dev, "WARNING! Controller is no "
2355 "longer running! code= 0x%x\n", code);
2356 }
2357 }
2358 }
2359
2360 /*
2361 * Interface Function Vectors
2362 */
2363
2364 /*
2365 * Read the current firmware status word.
2366 */
2367 static int
2368 aac_sa_get_fwstatus(struct aac_softc *sc)
2369 {
2370 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2371
2372 return(AAC_MEM0_GETREG4(sc, AAC_SA_FWSTATUS));
2373 }
2374
2375 static int
2376 aac_rx_get_fwstatus(struct aac_softc *sc)
2377 {
2378 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2379
2380 return(AAC_MEM0_GETREG4(sc, sc->flags & AAC_FLAGS_NEW_COMM ?
2381 AAC_RX_OMR0 : AAC_RX_FWSTATUS));
2382 }
2383
2384 static int
2385 aac_rkt_get_fwstatus(struct aac_softc *sc)
2386 {
2387 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2388
2389 return(AAC_MEM0_GETREG4(sc, sc->flags & AAC_FLAGS_NEW_COMM ?
2390 AAC_RKT_OMR0 : AAC_RKT_FWSTATUS));
2391 }
2392
2393 /*
2394 * Notify the controller of a change in a given queue
2395 */
2396
2397 static void
2398 aac_sa_qnotify(struct aac_softc *sc, int qbit)
2399 {
2400 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2401
2402 AAC_MEM0_SETREG2(sc, AAC_SA_DOORBELL1_SET, qbit);
2403 }
2404
2405 static void
2406 aac_rx_qnotify(struct aac_softc *sc, int qbit)
2407 {
2408 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2409
2410 AAC_MEM0_SETREG4(sc, AAC_RX_IDBR, qbit);
2411 }
2412
2413 static void
2414 aac_rkt_qnotify(struct aac_softc *sc, int qbit)
2415 {
2416 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2417
2418 AAC_MEM0_SETREG4(sc, AAC_RKT_IDBR, qbit);
2419 }
2420
2421 /*
2422 * Get the interrupt reason bits
2423 */
2424 static int
2425 aac_sa_get_istatus(struct aac_softc *sc)
2426 {
2427 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2428
2429 return(AAC_MEM0_GETREG2(sc, AAC_SA_DOORBELL0));
2430 }
2431
2432 static int
2433 aac_rx_get_istatus(struct aac_softc *sc)
2434 {
2435 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2436
2437 return(AAC_MEM0_GETREG4(sc, AAC_RX_ODBR));
2438 }
2439
2440 static int
2441 aac_rkt_get_istatus(struct aac_softc *sc)
2442 {
2443 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2444
2445 return(AAC_MEM0_GETREG4(sc, AAC_RKT_ODBR));
2446 }
2447
2448 /*
2449 * Clear some interrupt reason bits
2450 */
2451 static void
2452 aac_sa_clear_istatus(struct aac_softc *sc, int mask)
2453 {
2454 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2455
2456 AAC_MEM0_SETREG2(sc, AAC_SA_DOORBELL0_CLEAR, mask);
2457 }
2458
2459 static void
2460 aac_rx_clear_istatus(struct aac_softc *sc, int mask)
2461 {
2462 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2463
2464 AAC_MEM0_SETREG4(sc, AAC_RX_ODBR, mask);
2465 }
2466
2467 static void
2468 aac_rkt_clear_istatus(struct aac_softc *sc, int mask)
2469 {
2470 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2471
2472 AAC_MEM0_SETREG4(sc, AAC_RKT_ODBR, mask);
2473 }
2474
2475 /*
2476 * Populate the mailbox and set the command word
2477 */
2478 static void
2479 aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command,
2480 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2481 {
2482 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2483
2484 AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX, command);
2485 AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX + 4, arg0);
2486 AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX + 8, arg1);
2487 AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX + 12, arg2);
2488 AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX + 16, arg3);
2489 }
2490
2491 static void
2492 aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command,
2493 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2494 {
2495 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2496
2497 AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX, command);
2498 AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX + 4, arg0);
2499 AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX + 8, arg1);
2500 AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX + 12, arg2);
2501 AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX + 16, arg3);
2502 }
2503
2504 static void
2505 aac_rkt_set_mailbox(struct aac_softc *sc, u_int32_t command, u_int32_t arg0,
2506 u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2507 {
2508 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2509
2510 AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX, command);
2511 AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX + 4, arg0);
2512 AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX + 8, arg1);
2513 AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX + 12, arg2);
2514 AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX + 16, arg3);
2515 }
2516
2517 /*
2518 * Fetch the immediate command status word
2519 */
2520 static int
2521 aac_sa_get_mailbox(struct aac_softc *sc, int mb)
2522 {
2523 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2524
2525 return(AAC_MEM1_GETREG4(sc, AAC_SA_MAILBOX + (mb * 4)));
2526 }
2527
2528 static int
2529 aac_rx_get_mailbox(struct aac_softc *sc, int mb)
2530 {
2531 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2532
2533 return(AAC_MEM1_GETREG4(sc, AAC_RX_MAILBOX + (mb * 4)));
2534 }
2535
2536 static int
2537 aac_rkt_get_mailbox(struct aac_softc *sc, int mb)
2538 {
2539 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2540
2541 return(AAC_MEM1_GETREG4(sc, AAC_RKT_MAILBOX + (mb * 4)));
2542 }
2543
2544 /*
2545 * Set/clear interrupt masks
2546 */
2547 static void
2548 aac_sa_set_interrupts(struct aac_softc *sc, int enable)
2549 {
2550 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "%sable interrupts", enable ? "en" : "dis");
2551
2552 if (enable) {
2553 AAC_MEM0_SETREG2((sc), AAC_SA_MASK0_CLEAR, AAC_DB_INTERRUPTS);
2554 } else {
2555 AAC_MEM0_SETREG2((sc), AAC_SA_MASK0_SET, ~0);
2556 }
2557 }
2558
2559 static void
2560 aac_rx_set_interrupts(struct aac_softc *sc, int enable)
2561 {
2562 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "%sable interrupts", enable ? "en" : "dis");
2563
2564 if (enable) {
2565 if (sc->flags & AAC_FLAGS_NEW_COMM)
2566 AAC_MEM0_SETREG4(sc, AAC_RX_OIMR, ~AAC_DB_INT_NEW_COMM);
2567 else
2568 AAC_MEM0_SETREG4(sc, AAC_RX_OIMR, ~AAC_DB_INTERRUPTS);
2569 } else {
2570 AAC_MEM0_SETREG4(sc, AAC_RX_OIMR, ~0);
2571 }
2572 }
2573
2574 static void
2575 aac_rkt_set_interrupts(struct aac_softc *sc, int enable)
2576 {
2577 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "%sable interrupts", enable ? "en" : "dis");
2578
2579 if (enable) {
2580 if (sc->flags & AAC_FLAGS_NEW_COMM)
2581 AAC_MEM0_SETREG4(sc, AAC_RKT_OIMR, ~AAC_DB_INT_NEW_COMM);
2582 else
2583 AAC_MEM0_SETREG4(sc, AAC_RKT_OIMR, ~AAC_DB_INTERRUPTS);
2584 } else {
2585 AAC_MEM0_SETREG4(sc, AAC_RKT_OIMR, ~0);
2586 }
2587 }
2588
2589 /*
2590 * New comm. interface: Send command functions
2591 */
2592 static int
2593 aac_rx_send_command(struct aac_softc *sc, struct aac_command *cm)
2594 {
2595 u_int32_t index, device;
2596
2597 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "send command (new comm.)");
2598
2599 index = AAC_MEM0_GETREG4(sc, AAC_RX_IQUE);
2600 if (index == 0xffffffffL)
2601 index = AAC_MEM0_GETREG4(sc, AAC_RX_IQUE);
2602 if (index == 0xffffffffL)
2603 return index;
2604 aac_enqueue_busy(cm);
2605 device = index;
2606 AAC_MEM1_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys & 0xffffffffUL));
2607 device += 4;
2608 AAC_MEM1_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys >> 32));
2609 device += 4;
2610 AAC_MEM1_SETREG4(sc, device, cm->cm_fib->Header.Size);
2611 AAC_MEM0_SETREG4(sc, AAC_RX_IQUE, index);
2612 return 0;
2613 }
2614
2615 static int
2616 aac_rkt_send_command(struct aac_softc *sc, struct aac_command *cm)
2617 {
2618 u_int32_t index, device;
2619
2620 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "send command (new comm.)");
2621
2622 index = AAC_MEM0_GETREG4(sc, AAC_RKT_IQUE);
2623 if (index == 0xffffffffL)
2624 index = AAC_MEM0_GETREG4(sc, AAC_RKT_IQUE);
2625 if (index == 0xffffffffL)
2626 return index;
2627 aac_enqueue_busy(cm);
2628 device = index;
2629 AAC_MEM1_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys & 0xffffffffUL));
2630 device += 4;
2631 AAC_MEM1_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys >> 32));
2632 device += 4;
2633 AAC_MEM1_SETREG4(sc, device, cm->cm_fib->Header.Size);
2634 AAC_MEM0_SETREG4(sc, AAC_RKT_IQUE, index);
2635 return 0;
2636 }
2637
2638 /*
2639 * New comm. interface: get, set outbound queue index
2640 */
2641 static int
2642 aac_rx_get_outb_queue(struct aac_softc *sc)
2643 {
2644 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2645
2646 return(AAC_MEM0_GETREG4(sc, AAC_RX_OQUE));
2647 }
2648
2649 static int
2650 aac_rkt_get_outb_queue(struct aac_softc *sc)
2651 {
2652 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2653
2654 return(AAC_MEM0_GETREG4(sc, AAC_RKT_OQUE));
2655 }
2656
2657 static void
2658 aac_rx_set_outb_queue(struct aac_softc *sc, int index)
2659 {
2660 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2661
2662 AAC_MEM0_SETREG4(sc, AAC_RX_OQUE, index);
2663 }
2664
2665 static void
2666 aac_rkt_set_outb_queue(struct aac_softc *sc, int index)
2667 {
2668 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2669
2670 AAC_MEM0_SETREG4(sc, AAC_RKT_OQUE, index);
2671 }
2672
2673 /*
2674 * Debugging and Diagnostics
2675 */
2676
2677 /*
2678 * Print some information about the controller.
2679 */
2680 static void
2681 aac_describe_controller(struct aac_softc *sc)
2682 {
2683 struct aac_fib *fib;
2684 struct aac_adapter_info *info;
2685 char *adapter_type = "Adaptec RAID controller";
2686
2687 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2688
2689 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
2690 aac_alloc_sync_fib(sc, &fib);
2691
2692 fib->data[0] = 0;
2693 if (aac_sync_fib(sc, RequestAdapterInfo, 0, fib, 1)) {
2694 device_printf(sc->aac_dev, "RequestAdapterInfo failed\n");
2695 aac_release_sync_fib(sc);
2696 lockmgr(&sc->aac_io_lock, LK_RELEASE);
2697 return;
2698 }
2699
2700 /* save the kernel revision structure for later use */
2701 info = (struct aac_adapter_info *)&fib->data[0];
2702 sc->aac_revision = info->KernelRevision;
2703
2704 if (bootverbose) {
2705 device_printf(sc->aac_dev, "%s %dMHz, %dMB memory "
2706 "(%dMB cache, %dMB execution), %s\n",
2707 aac_describe_code(aac_cpu_variant, info->CpuVariant),
2708 info->ClockSpeed, info->TotalMem / (1024 * 1024),
2709 info->BufferMem / (1024 * 1024),
2710 info->ExecutionMem / (1024 * 1024),
2711 aac_describe_code(aac_battery_platform,
2712 info->batteryPlatform));
2713
2714 device_printf(sc->aac_dev,
2715 "Kernel %d.%d-%d, Build %d, S/N %6X\n",
2716 info->KernelRevision.external.comp.major,
2717 info->KernelRevision.external.comp.minor,
2718 info->KernelRevision.external.comp.dash,
2719 info->KernelRevision.buildNumber,
2720 (u_int32_t)(info->SerialNumber & 0xffffff));
2721
2722 device_printf(sc->aac_dev, "Supported Options=%pb%i\n",
2723 "\20"
2724 "\1SNAPSHOT"
2725 "\2CLUSTERS"
2726 "\3WCACHE"
2727 "\4DATA64"
2728 "\5HOSTTIME"
2729 "\6RAID50"
2730 "\7WINDOW4GB"
2731 "\10SCSIUPGD"
2732 "\11SOFTERR"
2733 "\12NORECOND"
2734 "\13SGMAP64"
2735 "\14ALARM"
2736 "\15NONDASD"
2737 "\16SCSIMGT"
2738 "\17RAIDSCSI"
2739 "\21ADPTINFO"
2740 "\22NEWCOMM"
2741 "\23ARRAY64BIT"
2742 "\24HEATSENSOR"
2743 , sc->supported_options);
2744 }
2745
2746 if (sc->supported_options & AAC_SUPPORTED_SUPPLEMENT_ADAPTER_INFO) {
2747 fib->data[0] = 0;
2748 if (aac_sync_fib(sc, RequestSupplementAdapterInfo, 0, fib, 1))
2749 device_printf(sc->aac_dev,
2750 "RequestSupplementAdapterInfo failed\n");
2751 else
2752 adapter_type = ((struct aac_supplement_adapter_info *)
2753 &fib->data[0])->AdapterTypeText;
2754 }
2755 device_printf(sc->aac_dev, "%s, aac driver %d.%d.%d-%d\n",
2756 adapter_type,
2757 AAC_DRIVER_MAJOR_VERSION, AAC_DRIVER_MINOR_VERSION,
2758 AAC_DRIVER_BUGFIX_LEVEL, AAC_DRIVER_BUILD);
2759
2760 aac_release_sync_fib(sc);
2761 lockmgr(&sc->aac_io_lock, LK_RELEASE);
2762 }
2763
2764 /*
2765 * Look up a text description of a numeric error code and return a pointer to
2766 * same.
2767 */
2768 static const char *
2769 aac_describe_code(const struct aac_code_lookup *table, u_int32_t code)
2770 {
2771 int i;
2772
2773 for (i = 0; table[i].string != NULL; i++)
2774 if (table[i].code == code)
2775 return(table[i].string);
2776 return(table[i + 1].string);
2777 }
2778
2779 /*
2780 * Management Interface
2781 */
2782
2783 static int
2784 aac_open(struct dev_open_args *ap)
2785 {
2786 cdev_t dev = ap->a_head.a_dev;
2787 struct aac_softc *sc;
2788
2789 sc = dev->si_drv1;
2790 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2791 device_busy(sc->aac_dev);
2792
2793 return 0;
2794 }
2795
2796 static int
2797 aac_ioctl(struct dev_ioctl_args *ap)
2798 {
2799 caddr_t arg = ap->a_data;
2800 cdev_t dev = ap->a_head.a_dev;
2801 u_long cmd = ap->a_cmd;
2802 union aac_statrequest *as;
2803 struct aac_softc *sc;
2804 int error = 0;
2805
2806 as = (union aac_statrequest *)arg;
2807 sc = dev->si_drv1;
2808 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2809
2810 switch (cmd) {
2811 case AACIO_STATS:
2812 switch (as->as_item) {
2813 case AACQ_FREE:
2814 case AACQ_BIO:
2815 case AACQ_READY:
2816 case AACQ_BUSY:
2817 bcopy(&sc->aac_qstat[as->as_item], &as->as_qstat,
2818 sizeof(struct aac_qstat));
2819 break;
2820 default:
2821 error = ENOENT;
2822 break;
2823 }
2824 break;
2825
2826 case FSACTL_SENDFIB:
2827 case FSACTL_SEND_LARGE_FIB:
2828 arg = *(caddr_t*)arg;
2829 case FSACTL_LNX_SENDFIB:
2830 case FSACTL_LNX_SEND_LARGE_FIB:
2831 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_SENDFIB");
2832 error = aac_ioctl_sendfib(sc, arg);
2833 break;
2834 case FSACTL_SEND_RAW_SRB:
2835 arg = *(caddr_t*)arg;
2836 case FSACTL_LNX_SEND_RAW_SRB:
2837 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_SEND_RAW_SRB");
2838 error = aac_ioctl_send_raw_srb(sc, arg);
2839 break;
2840 case FSACTL_AIF_THREAD:
2841 case FSACTL_LNX_AIF_THREAD:
2842 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_AIF_THREAD");
2843 error = EINVAL;
2844 break;
2845 case FSACTL_OPEN_GET_ADAPTER_FIB:
2846 arg = *(caddr_t*)arg;
2847 case FSACTL_LNX_OPEN_GET_ADAPTER_FIB:
2848 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_OPEN_GET_ADAPTER_FIB");
2849 error = aac_open_aif(sc, arg);
2850 break;
2851 case FSACTL_GET_NEXT_ADAPTER_FIB:
2852 arg = *(caddr_t*)arg;
2853 case FSACTL_LNX_GET_NEXT_ADAPTER_FIB:
2854 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_GET_NEXT_ADAPTER_FIB");
2855 error = aac_getnext_aif(sc, arg);
2856 break;
2857 case FSACTL_CLOSE_GET_ADAPTER_FIB:
2858 arg = *(caddr_t*)arg;
2859 case FSACTL_LNX_CLOSE_GET_ADAPTER_FIB:
2860 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_CLOSE_GET_ADAPTER_FIB");
2861 error = aac_close_aif(sc, arg);
2862 break;
2863 case FSACTL_MINIPORT_REV_CHECK:
2864 arg = *(caddr_t*)arg;
2865 case FSACTL_LNX_MINIPORT_REV_CHECK:
2866 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_MINIPORT_REV_CHECK");
2867 error = aac_rev_check(sc, arg);
2868 break;
2869 case FSACTL_QUERY_DISK:
2870 arg = *(caddr_t*)arg;
2871 case FSACTL_LNX_QUERY_DISK:
2872 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_QUERY_DISK");
2873 error = aac_query_disk(sc, arg);
2874 break;
2875 case FSACTL_DELETE_DISK:
2876 case FSACTL_LNX_DELETE_DISK:
2877 /*
2878 * We don't trust the underland to tell us when to delete a
2879 * container, rather we rely on an AIF coming from the
2880 * controller
2881 */
2882 error = 0;
2883 break;
2884 case FSACTL_GET_PCI_INFO:
2885 arg = *(caddr_t*)arg;
2886 case FSACTL_LNX_GET_PCI_INFO:
2887 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_GET_PCI_INFO");
2888 error = aac_get_pci_info(sc, arg);
2889 break;
2890 case FSACTL_GET_FEATURES:
2891 arg = *(caddr_t*)arg;
2892 case FSACTL_LNX_GET_FEATURES:
2893 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_GET_FEATURES");
2894 error = aac_supported_features(sc, arg);
2895 break;
2896 default:
2897 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "unsupported cmd 0x%lx\n", cmd);
2898 error = EINVAL;
2899 break;
2900 }
2901 return(error);
2902 }
2903
2904 static struct filterops aac_filterops =
2905 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, aac_filter_detach, aac_filter_read };
2906
2907 static int
2908 aac_kqfilter(struct dev_kqfilter_args *ap)
2909 {
2910 cdev_t dev = ap->a_head.a_dev;
2911 struct aac_softc *sc = dev->si_drv1;
2912 struct knote *kn = ap->a_kn;
2913 struct klist *klist;
2914
2915 ap->a_result = 0;
2916
2917 switch (kn->kn_filter) {
2918 case EVFILT_READ:
2919 kn->kn_fop = &aac_filterops;
2920 kn->kn_hook = (caddr_t)sc;
2921 break;
2922 default:
2923 ap->a_result = EOPNOTSUPP;
2924 return (0);
2925 }
2926
2927 klist = &sc->rcv_kq.ki_note;
2928 knote_insert(klist, kn);
2929
2930 return (0);
2931 }
2932
2933 static void
2934 aac_filter_detach(struct knote *kn)
2935 {
2936 struct aac_softc *sc = (struct aac_softc *)kn->kn_hook;
2937 struct klist *klist;
2938
2939 klist = &sc->rcv_kq.ki_note;
2940 knote_remove(klist, kn);
2941 }
2942
2943 static int
2944 aac_filter_read(struct knote *kn, long hint)
2945 {
2946 struct aac_softc *sc;
2947 struct aac_fib_context *ctx;
2948 int ret = 0;
2949
2950 sc = (struct aac_softc *)kn->kn_hook;
2951
2952 lockmgr(&sc->aac_aifq_lock, LK_EXCLUSIVE);
2953 for (ctx = sc->fibctx; ctx; ctx = ctx->next)
2954 if (ctx->ctx_idx != sc->aifq_idx || ctx->ctx_wrap)
2955 ret = 1;
2956 lockmgr(&sc->aac_aifq_lock, LK_RELEASE);
2957
2958 return(ret);
2959 }
2960
2961 static void
2962 aac_ioctl_event(struct aac_softc *sc, struct aac_event *event, void *arg)
2963 {
2964
2965 switch (event->ev_type) {
2966 case AAC_EVENT_CMFREE:
2967 KKASSERT(lockstatus(&sc->aac_io_lock, curthread) != 0);
2968 if (aac_alloc_command(sc, (struct aac_command **)arg)) {
2969 aac_add_event(sc, event);
2970 return;
2971 }
2972 kfree(event, M_AACBUF);
2973 wakeup(arg);
2974 break;
2975 default:
2976 break;
2977 }
2978 }
2979
2980 /*
2981 * Send a FIB supplied from userspace
2982 */
2983 static int
2984 aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib)
2985 {
2986 struct aac_command *cm;
2987 int size, error;
2988
2989 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2990
2991 cm = NULL;
2992
2993 /*
2994 * Get a command
2995 */
2996 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
2997 if (aac_alloc_command(sc, &cm)) {
2998 struct aac_event *event;
2999
3000 event = kmalloc(sizeof(struct aac_event), M_AACBUF,
3001 M_INTWAIT | M_ZERO);
3002 event->ev_type = AAC_EVENT_CMFREE;
3003 event->ev_callback = aac_ioctl_event;
3004 event->ev_arg = &cm;
3005 aac_add_event(sc, event);
3006 lksleep(&cm, &sc->aac_io_lock, 0, "sendfib", 0);
3007 }
3008 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3009
3010 /*
3011 * Fetch the FIB header, then re-copy to get data as well.
3012 */
3013 if ((error = copyin(ufib, cm->cm_fib,
3014 sizeof(struct aac_fib_header))) != 0)
3015 goto out;
3016 size = cm->cm_fib->Header.Size + sizeof(struct aac_fib_header);
3017 if (size > sc->aac_max_fib_size) {
3018 device_printf(sc->aac_dev, "incoming FIB oversized (%d > %d)\n",
3019 size, sc->aac_max_fib_size);
3020 size = sc->aac_max_fib_size;
3021 }
3022 if ((error = copyin(ufib, cm->cm_fib, size)) != 0)
3023 goto out;
3024 cm->cm_fib->Header.Size = size;
3025 cm->cm_timestamp = time_uptime;
3026
3027 /*
3028 * Pass the FIB to the controller, wait for it to complete.
3029 */
3030 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3031 error = aac_wait_command(cm);
3032 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3033 if (error != 0) {
3034 device_printf(sc->aac_dev,
3035 "aac_wait_command return %d\n", error);
3036 goto out;
3037 }
3038
3039 /*
3040 * Copy the FIB and data back out to the caller.
3041 */
3042 size = cm->cm_fib->Header.Size;
3043 if (size > sc->aac_max_fib_size) {
3044 device_printf(sc->aac_dev, "outbound FIB oversized (%d > %d)\n",
3045 size, sc->aac_max_fib_size);
3046 size = sc->aac_max_fib_size;
3047 }
3048 error = copyout(cm->cm_fib, ufib, size);
3049
3050 out:
3051 if (cm != NULL) {
3052 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3053 aac_release_command(cm);
3054 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3055 }
3056 return(error);
3057 }
3058
3059 /*
3060 * Send a passthrough FIB supplied from userspace
3061 */
3062 static int
3063 aac_ioctl_send_raw_srb(struct aac_softc *sc, caddr_t arg)
3064 {
3065 struct aac_command *cm;
3066 struct aac_event *event;
3067 struct aac_fib *fib;
3068 struct aac_srb *srbcmd, *user_srb;
3069 struct aac_sg_entry *sge;
3070 #ifdef __x86_64__
3071 struct aac_sg_entry64 *sge64;
3072 #endif
3073 void *srb_sg_address, *ureply;
3074 uint32_t fibsize, srb_sg_bytecount;
3075 int error, transfer_data;
3076
3077 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3078
3079 cm = NULL;
3080 transfer_data = 0;
3081 fibsize = 0;
3082 user_srb = (struct aac_srb *)arg;
3083
3084 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3085 if (aac_alloc_command(sc, &cm)) {
3086 event = kmalloc(sizeof(struct aac_event), M_AACBUF,
3087 M_NOWAIT | M_ZERO);
3088 if (event == NULL) {
3089 error = EBUSY;
3090 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3091 goto out;
3092 }
3093 event->ev_type = AAC_EVENT_CMFREE;
3094 event->ev_callback = aac_ioctl_event;
3095 event->ev_arg = &cm;
3096 aac_add_event(sc, event);
3097 lksleep(cm, &sc->aac_io_lock, 0, "aacraw", 0);
3098 }
3099 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3100
3101 cm->cm_data = NULL;
3102 fib = cm->cm_fib;
3103 srbcmd = (struct aac_srb *)fib->data;
3104 error = copyin(&user_srb->data_len, &fibsize, sizeof(uint32_t));
3105 if (error != 0)
3106 goto out;
3107 if (fibsize > (sc->aac_max_fib_size - sizeof(struct aac_fib_header))) {
3108 error = EINVAL;
3109 goto out;
3110 }
3111 error = copyin(user_srb, srbcmd, fibsize);
3112 if (error != 0)
3113 goto out;
3114 srbcmd->function = 0;
3115 srbcmd->retry_limit = 0;
3116 if (srbcmd->sg_map.SgCount > 1) {
3117 error = EINVAL;
3118 goto out;
3119 }
3120
3121 /* Retrieve correct SG entries. */
3122 if (fibsize == (sizeof(struct aac_srb) +
3123 srbcmd->sg_map.SgCount * sizeof(struct aac_sg_entry))) {
3124 sge = srbcmd->sg_map.SgEntry;
3125 srb_sg_bytecount = sge->SgByteCount;
3126 srb_sg_address = (void *)(uintptr_t)sge->SgAddress;
3127 }
3128 #ifdef __x86_64__
3129 else if (fibsize == (sizeof(struct aac_srb) +
3130 srbcmd->sg_map.SgCount * sizeof(struct aac_sg_entry64))) {
3131 sge = NULL;
3132 sge64 = (struct aac_sg_entry64 *)srbcmd->sg_map.SgEntry;
3133 srb_sg_bytecount = sge64->SgByteCount;
3134 srb_sg_address = (void *)sge64->SgAddress;
3135 if (sge64->SgAddress > 0xffffffffull &&
3136 (sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
3137 error = EINVAL;
3138 goto out;
3139 }
3140 }
3141 #endif
3142 else {
3143 error = EINVAL;
3144 goto out;
3145 }
3146 ureply = (char *)arg + fibsize;
3147 srbcmd->data_len = srb_sg_bytecount;
3148 if (srbcmd->sg_map.SgCount == 1)
3149 transfer_data = 1;
3150
3151 cm->cm_sgtable = (struct aac_sg_table *)&srbcmd->sg_map;
3152 if (transfer_data) {
3153 cm->cm_datalen = srb_sg_bytecount;
3154 cm->cm_data = kmalloc(cm->cm_datalen, M_AACBUF, M_NOWAIT);
3155 if (cm->cm_data == NULL) {
3156 error = ENOMEM;
3157 goto out;
3158 }
3159 if (srbcmd->flags & AAC_SRB_FLAGS_DATA_IN)
3160 cm->cm_flags |= AAC_CMD_DATAIN;
3161 if (srbcmd->flags & AAC_SRB_FLAGS_DATA_OUT) {
3162 cm->cm_flags |= AAC_CMD_DATAOUT;
3163 error = copyin(srb_sg_address, cm->cm_data,
3164 cm->cm_datalen);
3165 if (error != 0)
3166 goto out;
3167 }
3168 }
3169
3170 fib->Header.Size = sizeof(struct aac_fib_header) +
3171 sizeof(struct aac_srb);
3172 fib->Header.XferState =
3173 AAC_FIBSTATE_HOSTOWNED |
3174 AAC_FIBSTATE_INITIALISED |
3175 AAC_FIBSTATE_EMPTY |
3176 AAC_FIBSTATE_FROMHOST |
3177 AAC_FIBSTATE_REXPECTED |
3178 AAC_FIBSTATE_NORM |
3179 AAC_FIBSTATE_ASYNC |
3180 AAC_FIBSTATE_FAST_RESPONSE;
3181 fib->Header.Command = (sc->flags & AAC_FLAGS_SG_64BIT) != 0 ?
3182 ScsiPortCommandU64 : ScsiPortCommand;
3183
3184 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3185 aac_wait_command(cm);
3186 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3187
3188 if (transfer_data && (srbcmd->flags & AAC_SRB_FLAGS_DATA_IN) != 0) {
3189 error = copyout(cm->cm_data, srb_sg_address, cm->cm_datalen);
3190 if (error != 0)
3191 goto out;
3192 }
3193 error = copyout(fib->data, ureply, sizeof(struct aac_srb_response));
3194 out:
3195 if (cm != NULL) {
3196 if (cm->cm_data != NULL)
3197 kfree(cm->cm_data, M_AACBUF);
3198 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3199 aac_release_command(cm);
3200 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3201 }
3202 return(error);
3203 }
3204
3205 static int
3206 aac_close(struct dev_close_args *ap)
3207 {
3208 cdev_t dev = ap->a_head.a_dev;
3209 struct aac_softc *sc;
3210
3211 sc = dev->si_drv1;
3212 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3213 get_mplock();
3214 device_unbusy(sc->aac_dev);
3215 rel_mplock();
3216
3217 return 0;
3218 }
3219
3220 /*
3221 * Handle an AIF sent to us by the controller; queue it for later reference.
3222 * If the queue fills up, then drop the older entries.
3223 */
3224 static void
3225 aac_handle_aif(struct aac_softc *sc, struct aac_fib *fib)
3226 {
3227 struct aac_aif_command *aif;
3228 struct aac_container *co, *co_next;
3229 struct aac_fib_context *ctx;
3230 struct aac_mntinforesp *mir;
3231 int next, current, found;
3232 int count = 0, added = 0, i = 0;
3233 uint32_t channel;
3234
3235 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3236
3237 aif = (struct aac_aif_command*)&fib->data[0];
3238 aac_print_aif(sc, aif);
3239
3240 /* Is it an event that we should care about? */
3241 switch (aif->command) {
3242 case AifCmdEventNotify:
3243 switch (aif->data.EN.type) {
3244 case AifEnAddContainer:
3245 case AifEnDeleteContainer:
3246 /*
3247 * A container was added or deleted, but the message
3248 * doesn't tell us anything else! Re-enumerate the
3249 * containers and sort things out.
3250 */
3251 aac_alloc_sync_fib(sc, &fib);
3252 do {
3253 /*
3254 * Ask the controller for its containers one at
3255 * a time.
3256 * XXX What if the controller's list changes
3257 * midway through this enumaration?
3258 * XXX This should be done async.
3259 */
3260 if ((mir = aac_get_container_info(sc, fib, i)) == NULL)
3261 continue;
3262 if (i == 0)
3263 count = mir->MntRespCount;
3264 /*
3265 * Check the container against our list.
3266 * co->co_found was already set to 0 in a
3267 * previous run.
3268 */
3269 if ((mir->Status == ST_OK) &&
3270 (mir->MntTable[0].VolType != CT_NONE)) {
3271 found = 0;
3272 TAILQ_FOREACH(co,
3273 &sc->aac_container_tqh,
3274 co_link) {
3275 if (co->co_mntobj.ObjectId ==
3276 mir->MntTable[0].ObjectId) {
3277 co->co_found = 1;
3278 found = 1;
3279 break;
3280 }
3281 }
3282 /*
3283 * If the container matched, continue
3284 * in the list.
3285 */
3286 if (found) {
3287 i++;
3288 continue;
3289 }
3290
3291 /*
3292 * This is a new container. Do all the
3293 * appropriate things to set it up.
3294 */
3295 aac_add_container(sc, mir, 1);
3296 added = 1;
3297 }
3298 i++;
3299 } while ((i < count) && (i < AAC_MAX_CONTAINERS));
3300 aac_release_sync_fib(sc);
3301
3302 /*
3303 * Go through our list of containers and see which ones
3304 * were not marked 'found'. Since the controller didn't
3305 * list them they must have been deleted. Do the
3306 * appropriate steps to destroy the device. Also reset
3307 * the co->co_found field.
3308 */
3309 co = TAILQ_FIRST(&sc->aac_container_tqh);
3310 while (co != NULL) {
3311 if (co->co_found == 0) {
3312 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3313 get_mplock();
3314 device_delete_child(sc->aac_dev,
3315 co->co_disk);
3316 rel_mplock();
3317 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3318 co_next = TAILQ_NEXT(co, co_link);
3319 lockmgr(&sc->aac_container_lock, LK_EXCLUSIVE);
3320 TAILQ_REMOVE(&sc->aac_container_tqh, co,
3321 co_link);
3322 lockmgr(&sc->aac_container_lock, LK_RELEASE);
3323 kfree(co, M_AACBUF);
3324 co = co_next;
3325 } else {
3326 co->co_found = 0;
3327 co = TAILQ_NEXT(co, co_link);
3328 }
3329 }
3330
3331 /* Attach the newly created containers */
3332 if (added) {
3333 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3334 get_mplock();
3335 bus_generic_attach(sc->aac_dev);
3336 rel_mplock();
3337 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3338 }
3339
3340 break;
3341
3342 case AifEnEnclosureManagement:
3343 switch (aif->data.EN.data.EEE.eventType) {
3344 case AIF_EM_DRIVE_INSERTION:
3345 case AIF_EM_DRIVE_REMOVAL:
3346 channel = aif->data.EN.data.EEE.unitID;
3347 if (sc->cam_rescan_cb != NULL)
3348 sc->cam_rescan_cb(sc,
3349 (channel >> 24) & 0xF,
3350 (channel & 0xFFFF));
3351 break;
3352 }
3353 break;
3354
3355 case AifEnAddJBOD:
3356 case AifEnDeleteJBOD:
3357 channel = aif->data.EN.data.ECE.container;
3358 if (sc->cam_rescan_cb != NULL)
3359 sc->cam_rescan_cb(sc, (channel >> 24) & 0xF,
3360 AAC_CAM_TARGET_WILDCARD);
3361 break;
3362
3363 default:
3364 break;
3365 }
3366
3367 default:
3368 break;
3369 }
3370
3371 /* Copy the AIF data to the AIF queue for ioctl retrieval */
3372 lockmgr(&sc->aac_aifq_lock, LK_EXCLUSIVE);
3373 current = sc->aifq_idx;
3374 next = (current + 1) % AAC_AIFQ_LENGTH;
3375 if (next == 0)
3376 sc->aifq_filled = 1;
3377 bcopy(fib, &sc->aac_aifq[current], sizeof(struct aac_fib));
3378 /* modify AIF contexts */
3379 if (sc->aifq_filled) {
3380 for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3381 if (next == ctx->ctx_idx)
3382 ctx->ctx_wrap = 1;
3383 else if (current == ctx->ctx_idx && ctx->ctx_wrap)
3384 ctx->ctx_idx = next;
3385 }
3386 }
3387 sc->aifq_idx = next;
3388 /* On the off chance that someone is sleeping for an aif... */
3389 if (sc->aac_state & AAC_STATE_AIF_SLEEPER)
3390 wakeup(sc->aac_aifq);
3391 /* token may have been lost */
3392 /* Wakeup any poll()ers */
3393 KNOTE(&sc->rcv_kq.ki_note, 0);
3394 /* token may have been lost */
3395 lockmgr(&sc->aac_aifq_lock, LK_RELEASE);
3396 }
3397
3398 /*
3399 * Return the Revision of the driver to userspace and check to see if the
3400 * userspace app is possibly compatible. This is extremely bogus since
3401 * our driver doesn't follow Adaptec's versioning system. Cheat by just
3402 * returning what the card reported.
3403 */
3404 static int
3405 aac_rev_check(struct aac_softc *sc, caddr_t udata)
3406 {
3407 struct aac_rev_check rev_check;
3408 struct aac_rev_check_resp rev_check_resp;
3409 int error = 0;
3410
3411 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3412
3413 /*
3414 * Copyin the revision struct from userspace
3415 */
3416 if ((error = copyin(udata, (caddr_t)&rev_check,
3417 sizeof(struct aac_rev_check))) != 0) {
3418 return error;
3419 }
3420
3421 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "Userland revision= %d\n",
3422 rev_check.callingRevision.buildNumber);
3423
3424 /*
3425 * Doctor up the response struct.
3426 */
3427 rev_check_resp.possiblyCompatible = 1;
3428 rev_check_resp.adapterSWRevision.external.comp.major =
3429 AAC_DRIVER_MAJOR_VERSION;
3430 rev_check_resp.adapterSWRevision.external.comp.minor =
3431 AAC_DRIVER_MINOR_VERSION;
3432 rev_check_resp.adapterSWRevision.external.comp.type =
3433 AAC_DRIVER_TYPE;
3434 rev_check_resp.adapterSWRevision.external.comp.dash =
3435 AAC_DRIVER_BUGFIX_LEVEL;
3436 rev_check_resp.adapterSWRevision.buildNumber =
3437 AAC_DRIVER_BUILD;
3438
3439 return(copyout((caddr_t)&rev_check_resp, udata,
3440 sizeof(struct aac_rev_check_resp)));
3441 }
3442
3443 /*
3444 * Pass the fib context to the caller
3445 */
3446 static int
3447 aac_open_aif(struct aac_softc *sc, caddr_t arg)
3448 {
3449 struct aac_fib_context *fibctx, *ctx;
3450 int error = 0;
3451
3452 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3453
3454 fibctx = kmalloc(sizeof(struct aac_fib_context), M_AACBUF, M_NOWAIT|M_ZERO);
3455 if (fibctx == NULL)
3456 return (ENOMEM);
3457
3458 lockmgr(&sc->aac_aifq_lock, LK_EXCLUSIVE);
3459 /* all elements are already 0, add to queue */
3460 if (sc->fibctx == NULL)
3461 sc->fibctx = fibctx;
3462 else {
3463 for (ctx = sc->fibctx; ctx->next; ctx = ctx->next)
3464 ;
3465 ctx->next = fibctx;
3466 fibctx->prev = ctx;
3467 }
3468
3469 /* evaluate unique value */
3470 fibctx->unique = (*(u_int32_t *)&fibctx & 0xffffffff);
3471 ctx = sc->fibctx;
3472 while (ctx != fibctx) {
3473 if (ctx->unique == fibctx->unique) {
3474 fibctx->unique++;
3475 ctx = sc->fibctx;
3476 } else {
3477 ctx = ctx->next;
3478 }
3479 }
3480 lockmgr(&sc->aac_aifq_lock, LK_RELEASE);
3481
3482 error = copyout(&fibctx->unique, (void *)arg, sizeof(u_int32_t));
3483 if (error)
3484 aac_close_aif(sc, (caddr_t)ctx);
3485 return error;
3486 }
3487
3488 /*
3489 * Close the caller's fib context
3490 */
3491 static int
3492 aac_close_aif(struct aac_softc *sc, caddr_t arg)
3493 {
3494 struct aac_fib_context *ctx;
3495
3496 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3497
3498 lockmgr(&sc->aac_aifq_lock, LK_EXCLUSIVE);
3499 for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3500 if (ctx->unique == *(uint32_t *)&arg) {
3501 if (ctx == sc->fibctx)
3502 sc->fibctx = NULL;
3503 else {
3504 ctx->prev->next = ctx->next;
3505 if (ctx->next)
3506 ctx->next->prev = ctx->prev;
3507 }
3508 break;
3509 }
3510 }
3511 lockmgr(&sc->aac_aifq_lock, LK_RELEASE);
3512 if (ctx)
3513 kfree(ctx, M_AACBUF);
3514
3515 return 0;
3516 }
3517
3518 /*
3519 * Pass the caller the next AIF in their queue
3520 */
3521 static int
3522 aac_getnext_aif(struct aac_softc *sc, caddr_t arg)
3523 {
3524 struct get_adapter_fib_ioctl agf;
3525 struct aac_fib_context *ctx;
3526 int error;
3527
3528 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3529
3530 if ((error = copyin(arg, &agf, sizeof(agf))) == 0) {
3531 for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3532 if (agf.AdapterFibContext == ctx->unique)
3533 break;
3534 }
3535 if (!ctx)
3536 return (EFAULT);
3537
3538 error = aac_return_aif(sc, ctx, agf.AifFib);
3539 if (error == EAGAIN && agf.Wait) {
3540 fwprintf(sc, HBA_FLAGS_DBG_AIF_B, "aac_getnext_aif(): waiting for AIF");
3541 sc->aac_state |= AAC_STATE_AIF_SLEEPER;
3542 while (error == EAGAIN) {
3543 error = tsleep(sc->aac_aifq,
3544 PCATCH, "aacaif", 0);
3545 if (error == 0)
3546 error = aac_return_aif(sc, ctx, agf.AifFib);
3547 }
3548 sc->aac_state &= ~AAC_STATE_AIF_SLEEPER;
3549 }
3550 }
3551 return(error);
3552 }
3553
3554 /*
3555 * Hand the next AIF off the top of the queue out to userspace.
3556 */
3557 static int
3558 aac_return_aif(struct aac_softc *sc, struct aac_fib_context *ctx, caddr_t uptr)
3559 {
3560 int current, error;
3561
3562 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3563
3564 lockmgr(&sc->aac_aifq_lock, LK_EXCLUSIVE);
3565 current = ctx->ctx_idx;
3566 if (current == sc->aifq_idx && !ctx->ctx_wrap) {
3567 /* empty */
3568 lockmgr(&sc->aac_aifq_lock, LK_RELEASE);
3569 return (EAGAIN);
3570 }
3571 error =
3572 copyout(&sc->aac_aifq[current], (void *)uptr, sizeof(struct aac_fib));
3573 if (error)
3574 device_printf(sc->aac_dev,
3575 "aac_return_aif: copyout returned %d\n", error);
3576 else {
3577 ctx->ctx_wrap = 0;
3578 ctx->ctx_idx = (current + 1) % AAC_AIFQ_LENGTH;
3579 }
3580 lockmgr(&sc->aac_aifq_lock, LK_RELEASE);
3581 return(error);
3582 }
3583
3584 static int
3585 aac_get_pci_info(struct aac_softc *sc, caddr_t uptr)
3586 {
3587 struct aac_pci_info {
3588 u_int32_t bus;
3589 u_int32_t slot;
3590 } pciinf;
3591 int error;
3592
3593 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3594
3595 pciinf.bus = pci_get_bus(sc->aac_dev);
3596 pciinf.slot = pci_get_slot(sc->aac_dev);
3597
3598 error = copyout((caddr_t)&pciinf, uptr,
3599 sizeof(struct aac_pci_info));
3600
3601 return (error);
3602 }
3603
3604 static int
3605 aac_supported_features(struct aac_softc *sc, caddr_t uptr)
3606 {
3607 struct aac_features f;
3608 int error;
3609
3610 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3611
3612 if ((error = copyin(uptr, &f, sizeof (f))) != 0)
3613 return (error);
3614
3615 /*
3616 * When the management driver receives FSACTL_GET_FEATURES ioctl with
3617 * ALL zero in the featuresState, the driver will return the current
3618 * state of all the supported features, the data field will not be
3619 * valid.
3620 * When the management driver receives FSACTL_GET_FEATURES ioctl with
3621 * a specific bit set in the featuresState, the driver will return the
3622 * current state of this specific feature and whatever data that are
3623 * associated with the feature in the data field or perform whatever
3624 * action needed indicates in the data field.
3625 */
3626 if (f.feat.fValue == 0) {
3627 f.feat.fBits.largeLBA =
3628 (sc->flags & AAC_FLAGS_LBA_64BIT) ? 1 : 0;
3629 /* TODO: In the future, add other features state here as well */
3630 } else {
3631 if (f.feat.fBits.largeLBA)
3632 f.feat.fBits.largeLBA =
3633 (sc->flags & AAC_FLAGS_LBA_64BIT) ? 1 : 0;
3634 /* TODO: Add other features state and data in the future */
3635 }
3636
3637 error = copyout(&f, uptr, sizeof (f));
3638 return (error);
3639 }
3640
3641 /*
3642 * Give the userland some information about the container. The AAC arch
3643 * expects the driver to be a SCSI passthrough type driver, so it expects
3644 * the containers to have b:t:l numbers. Fake it.
3645 */
3646 static int
3647 aac_query_disk(struct aac_softc *sc, caddr_t uptr)
3648 {
3649 struct aac_query_disk query_disk;
3650 struct aac_container *co;
3651 struct aac_disk *disk;
3652 int error, id;
3653
3654 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3655
3656 disk = NULL;
3657
3658 error = copyin(uptr, (caddr_t)&query_disk,
3659 sizeof(struct aac_query_disk));
3660 if (error)
3661 return (error);
3662
3663 id = query_disk.ContainerNumber;
3664 if (id == -1)
3665 return (EINVAL);
3666
3667 lockmgr(&sc->aac_container_lock, LK_EXCLUSIVE);
3668 TAILQ_FOREACH(co, &sc->aac_container_tqh, co_link) {
3669 if (co->co_mntobj.ObjectId == id)
3670 break;
3671 }
3672
3673 if (co == NULL) {
3674 query_disk.Valid = 0;
3675 query_disk.Locked = 0;
3676 query_disk.Deleted = 1; /* XXX is this right? */
3677 } else {
3678 disk = device_get_softc(co->co_disk);
3679 query_disk.Valid = 1;
3680 query_disk.Locked =
3681 (disk->ad_flags & AAC_DISK_OPEN) ? 1 : 0;
3682 query_disk.Deleted = 0;
3683 query_disk.Bus = device_get_unit(sc->aac_dev);
3684 query_disk.Target = disk->unit;
3685 query_disk.Lun = 0;
3686 query_disk.UnMapped = 0;
3687 bcopy(disk->ad_dev_t->si_name,
3688 &query_disk.diskDeviceName[0], 10);
3689 }
3690 lockmgr(&sc->aac_container_lock, LK_RELEASE);
3691
3692 error = copyout((caddr_t)&query_disk, uptr,
3693 sizeof(struct aac_query_disk));
3694
3695 return (error);
3696 }
3697
3698 static void
3699 aac_get_bus_info(struct aac_softc *sc)
3700 {
3701 struct aac_fib *fib;
3702 struct aac_ctcfg *c_cmd;
3703 struct aac_ctcfg_resp *c_resp;
3704 struct aac_vmioctl *vmi;
3705 struct aac_vmi_businf_resp *vmi_resp;
3706 struct aac_getbusinf businfo;
3707 struct aac_sim *caminf;
3708 device_t child;
3709 int i, found, error;
3710
3711 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3712 aac_alloc_sync_fib(sc, &fib);
3713 c_cmd = (struct aac_ctcfg *)&fib->data[0];
3714 bzero(c_cmd, sizeof(struct aac_ctcfg));
3715
3716 c_cmd->Command = VM_ContainerConfig;
3717 c_cmd->cmd = CT_GET_SCSI_METHOD;
3718 c_cmd->param = 0;
3719
3720 error = aac_sync_fib(sc, ContainerCommand, 0, fib,
3721 sizeof(struct aac_ctcfg));
3722 if (error) {
3723 device_printf(sc->aac_dev, "Error %d sending "
3724 "VM_ContainerConfig command\n", error);
3725 aac_release_sync_fib(sc);
3726 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3727 return;
3728 }
3729
3730 c_resp = (struct aac_ctcfg_resp *)&fib->data[0];
3731 if (c_resp->Status != ST_OK) {
3732 device_printf(sc->aac_dev, "VM_ContainerConfig returned 0x%x\n",
3733 c_resp->Status);
3734 aac_release_sync_fib(sc);
3735 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3736 return;
3737 }
3738
3739 sc->scsi_method_id = c_resp->param;
3740
3741 vmi = (struct aac_vmioctl *)&fib->data[0];
3742 bzero(vmi, sizeof(struct aac_vmioctl));
3743
3744 vmi->Command = VM_Ioctl;
3745 vmi->ObjType = FT_DRIVE;
3746 vmi->MethId = sc->scsi_method_id;
3747 vmi->ObjId = 0;
3748 vmi->IoctlCmd = GetBusInfo;
3749
3750 error = aac_sync_fib(sc, ContainerCommand, 0, fib,
3751 sizeof(struct aac_vmi_businf_resp));
3752 if (error) {
3753 device_printf(sc->aac_dev, "Error %d sending VMIoctl command\n",
3754 error);
3755 aac_release_sync_fib(sc);
3756 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3757 return;
3758 }
3759
3760 vmi_resp = (struct aac_vmi_businf_resp *)&fib->data[0];
3761 if (vmi_resp->Status != ST_OK) {
3762 device_printf(sc->aac_dev, "VM_Ioctl returned %d\n",
3763 vmi_resp->Status);
3764 aac_release_sync_fib(sc);
3765 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3766 return;
3767 }
3768
3769 bcopy(&vmi_resp->BusInf, &businfo, sizeof(struct aac_getbusinf));
3770 aac_release_sync_fib(sc);
3771 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3772
3773 found = 0;
3774 for (i = 0; i < businfo.BusCount; i++) {
3775 if (businfo.BusValid[i] != AAC_BUS_VALID)
3776 continue;
3777
3778 caminf = (struct aac_sim *)kmalloc(sizeof(struct aac_sim),
3779 M_AACBUF, M_INTWAIT | M_ZERO);
3780
3781 child = device_add_child(sc->aac_dev, "aacp", -1);
3782 if (child == NULL) {
3783 device_printf(sc->aac_dev,
3784 "device_add_child failed for passthrough bus %d\n",
3785 i);
3786 kfree(caminf, M_AACBUF);
3787 break;
3788 }
3789
3790 caminf->TargetsPerBus = businfo.TargetsPerBus;
3791 caminf->BusNumber = i;
3792 caminf->InitiatorBusId = businfo.InitiatorBusId[i];
3793 caminf->aac_sc = sc;
3794 caminf->sim_dev = child;
3795
3796 device_set_ivars(child, caminf);
3797 device_set_desc(child, "SCSI Passthrough Bus");
3798 TAILQ_INSERT_TAIL(&sc->aac_sim_tqh, caminf, sim_link);
3799
3800 found = 1;
3801 }
3802
3803 if (found)
3804 bus_generic_attach(sc->aac_dev);
3805 }
DragonFly BSD