32
33/*
34 * Driver for the Adaptec 'FSA' family of PCI/SCSI RAID adapters.
35 */
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/sysctl.h>
46#include <sys/poll.h>
47#include <sys/ioccom.h>
48
49#include <sys/bus.h>
50#include <sys/conf.h>
51#include <sys/signalvar.h>
52#include <sys/time.h>
53#include <sys/eventhandler.h>
54
55#include <machine/bus_memio.h>
56#include <machine/bus.h>
57#include <machine/resource.h>
58
59#include <dev/aac/aacreg.h>
60#include <dev/aac/aac_ioctl.h>
61#include <dev/aac/aacvar.h>
62#include <dev/aac/aac_tables.h>
63
64static void aac_startup(void *arg);
65static void aac_add_container(struct aac_softc *sc,
66 struct aac_mntinforesp *mir, int f);
67static void aac_get_bus_info(struct aac_softc *sc);
68
69/* Command Processing */
70static void aac_timeout(struct aac_softc *sc);
71static int aac_map_command(struct aac_command *cm);
72static void aac_complete(void *context, int pending);
73static int aac_bio_command(struct aac_softc *sc, struct aac_command **cmp);
74static void aac_bio_complete(struct aac_command *cm);
75static int aac_wait_command(struct aac_command *cm, int timeout);
76static void aac_command_thread(struct aac_softc *sc);
77
78/* Command Buffer Management */
79static void aac_map_command_sg(void *arg, bus_dma_segment_t *segs,
80 int nseg, int error);
81static void aac_map_command_helper(void *arg, bus_dma_segment_t *segs,
82 int nseg, int error);
83static int aac_alloc_commands(struct aac_softc *sc);
84static void aac_free_commands(struct aac_softc *sc);
85static void aac_unmap_command(struct aac_command *cm);
86
87/* Hardware Interface */
88static void aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg,
89 int error);
90static int aac_check_firmware(struct aac_softc *sc);
91static int aac_init(struct aac_softc *sc);
92static int aac_sync_command(struct aac_softc *sc, u_int32_t command,
93 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2,
94 u_int32_t arg3, u_int32_t *sp);
95static int aac_enqueue_fib(struct aac_softc *sc, int queue,
96 struct aac_command *cm);
97static int aac_dequeue_fib(struct aac_softc *sc, int queue,
98 u_int32_t *fib_size, struct aac_fib **fib_addr);
99static int aac_enqueue_response(struct aac_softc *sc, int queue,
100 struct aac_fib *fib);
101
102/* Falcon/PPC interface */
103static int aac_fa_get_fwstatus(struct aac_softc *sc);
104static void aac_fa_qnotify(struct aac_softc *sc, int qbit);
105static int aac_fa_get_istatus(struct aac_softc *sc);
106static void aac_fa_clear_istatus(struct aac_softc *sc, int mask);
107static void aac_fa_set_mailbox(struct aac_softc *sc, u_int32_t command,
108 u_int32_t arg0, u_int32_t arg1,
109 u_int32_t arg2, u_int32_t arg3);
110static int aac_fa_get_mailbox(struct aac_softc *sc, int mb);
111static void aac_fa_set_interrupts(struct aac_softc *sc, int enable);
112
113struct aac_interface aac_fa_interface = {
114 aac_fa_get_fwstatus,
115 aac_fa_qnotify,
116 aac_fa_get_istatus,
117 aac_fa_clear_istatus,
118 aac_fa_set_mailbox,
119 aac_fa_get_mailbox,
120 aac_fa_set_interrupts
121};
122
123/* StrongARM interface */
124static int aac_sa_get_fwstatus(struct aac_softc *sc);
125static void aac_sa_qnotify(struct aac_softc *sc, int qbit);
126static int aac_sa_get_istatus(struct aac_softc *sc);
127static void aac_sa_clear_istatus(struct aac_softc *sc, int mask);
128static void aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command,
129 u_int32_t arg0, u_int32_t arg1,
130 u_int32_t arg2, u_int32_t arg3);
131static int aac_sa_get_mailbox(struct aac_softc *sc, int mb);
132static void aac_sa_set_interrupts(struct aac_softc *sc, int enable);
133
134struct aac_interface aac_sa_interface = {
135 aac_sa_get_fwstatus,
136 aac_sa_qnotify,
137 aac_sa_get_istatus,
138 aac_sa_clear_istatus,
139 aac_sa_set_mailbox,
140 aac_sa_get_mailbox,
141 aac_sa_set_interrupts
142};
143
144/* i960Rx interface */
145static int aac_rx_get_fwstatus(struct aac_softc *sc);
146static void aac_rx_qnotify(struct aac_softc *sc, int qbit);
147static int aac_rx_get_istatus(struct aac_softc *sc);
148static void aac_rx_clear_istatus(struct aac_softc *sc, int mask);
149static void aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command,
150 u_int32_t arg0, u_int32_t arg1,
151 u_int32_t arg2, u_int32_t arg3);
152static int aac_rx_get_mailbox(struct aac_softc *sc, int mb);
153static void aac_rx_set_interrupts(struct aac_softc *sc, int enable);
154
155struct aac_interface aac_rx_interface = {
156 aac_rx_get_fwstatus,
157 aac_rx_qnotify,
158 aac_rx_get_istatus,
159 aac_rx_clear_istatus,
160 aac_rx_set_mailbox,
161 aac_rx_get_mailbox,
162 aac_rx_set_interrupts
163};
164
165/* Debugging and Diagnostics */
166static void aac_describe_controller(struct aac_softc *sc);
167static char *aac_describe_code(struct aac_code_lookup *table,
168 u_int32_t code);
169
170/* Management Interface */
171static d_open_t aac_open;
172static d_close_t aac_close;
173static d_ioctl_t aac_ioctl;
174static d_poll_t aac_poll;
175static int aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib);
176static void aac_handle_aif(struct aac_softc *sc,
177 struct aac_fib *fib);
178static int aac_rev_check(struct aac_softc *sc, caddr_t udata);
179static int aac_getnext_aif(struct aac_softc *sc, caddr_t arg);
180static int aac_return_aif(struct aac_softc *sc, caddr_t uptr);
181static int aac_query_disk(struct aac_softc *sc, caddr_t uptr);
182
183static struct cdevsw aac_cdevsw = {
184 .d_open = aac_open,
185 .d_close = aac_close,
186 .d_ioctl = aac_ioctl,
187 .d_poll = aac_poll,
188 .d_name = "aac",
189};
190
191MALLOC_DEFINE(M_AACBUF, "aacbuf", "Buffers for the AAC driver");
192
193/* sysctl node */
194SYSCTL_NODE(_hw, OID_AUTO, aac, CTLFLAG_RD, 0, "AAC driver parameters");
195
196/*
197 * Device Interface
198 */
199
200/*
201 * Initialise the controller and softc
202 */
203int
204aac_attach(struct aac_softc *sc)
205{
206 int error, unit;
207
208 debug_called(1);
209
210 /*
211 * Initialise per-controller queues.
212 */
213 aac_initq_free(sc);
214 aac_initq_ready(sc);
215 aac_initq_busy(sc);
216 aac_initq_bio(sc);
217
218 /*
219 * Initialise command-completion task.
220 */
221 TASK_INIT(&sc->aac_task_complete, 0, aac_complete, sc);
222
223 /* disable interrupts before we enable anything */
224 AAC_MASK_INTERRUPTS(sc);
225
226 /* mark controller as suspended until we get ourselves organised */
227 sc->aac_state |= AAC_STATE_SUSPEND;
228
229 /*
230 * Check that the firmware on the card is supported.
231 */
232 if ((error = aac_check_firmware(sc)) != 0)
233 return(error);
234
235 /*
236 * Initialize locks
237 */
238 AAC_LOCK_INIT(&sc->aac_sync_lock, "AAC sync FIB lock");
239 AAC_LOCK_INIT(&sc->aac_aifq_lock, "AAC AIF lock");
240 AAC_LOCK_INIT(&sc->aac_io_lock, "AAC I/O lock");
241 AAC_LOCK_INIT(&sc->aac_container_lock, "AAC container lock");
242 TAILQ_INIT(&sc->aac_container_tqh);
243
244 /* Initialize the local AIF queue pointers */
245 sc->aac_aifq_head = sc->aac_aifq_tail = AAC_AIFQ_LENGTH;
246
247 /*
248 * Initialise the adapter.
249 */
250 if ((error = aac_init(sc)) != 0)
251 return(error);
252
253 /*
254 * Print a little information about the controller.
255 */
256 aac_describe_controller(sc);
257
258 /*
259 * Register to probe our containers later.
260 */
261 sc->aac_ich.ich_func = aac_startup;
262 sc->aac_ich.ich_arg = sc;
263 if (config_intrhook_establish(&sc->aac_ich) != 0) {
264 device_printf(sc->aac_dev,
265 "can't establish configuration hook\n");
266 return(ENXIO);
267 }
268
269 /*
270 * Make the control device.
271 */
272 unit = device_get_unit(sc->aac_dev);
273 sc->aac_dev_t = make_dev(&aac_cdevsw, unit, UID_ROOT, GID_OPERATOR,
274 0640, "aac%d", unit);
275 (void)make_dev_alias(sc->aac_dev_t, "afa%d", unit);
276 (void)make_dev_alias(sc->aac_dev_t, "hpn%d", unit);
277 sc->aac_dev_t->si_drv1 = sc;
278
279 /* Create the AIF thread */
280 if (kthread_create((void(*)(void *))aac_command_thread, sc,
281 &sc->aifthread, 0, 0, "aac%daif", unit))
282 panic("Could not create AIF thread\n");
283
284 /* Register the shutdown method to only be called post-dump */
285 if ((sc->eh = EVENTHANDLER_REGISTER(shutdown_final, aac_shutdown,
286 sc->aac_dev, SHUTDOWN_PRI_DEFAULT)) == NULL)
287 device_printf(sc->aac_dev,
288 "shutdown event registration failed\n");
289
290 /* Register with CAM for the non-DASD devices */
291 if ((sc->flags & AAC_FLAGS_ENABLE_CAM) != 0) {
292 TAILQ_INIT(&sc->aac_sim_tqh);
293 aac_get_bus_info(sc);
294 }
295
296 return(0);
297}
298
299/*
300 * Probe for containers, create disks.
301 */
302static void
303aac_startup(void *arg)
304{
305 struct aac_softc *sc;
306 struct aac_fib *fib;
307 struct aac_mntinfo *mi;
308 struct aac_mntinforesp *mir = NULL;
309 int count = 0, i = 0;
310
311 debug_called(1);
312
313 sc = (struct aac_softc *)arg;
314
315 /* disconnect ourselves from the intrhook chain */
316 config_intrhook_disestablish(&sc->aac_ich);
317
318 aac_alloc_sync_fib(sc, &fib, 0);
319 mi = (struct aac_mntinfo *)&fib->data[0];
320
321 /* loop over possible containers */
322 do {
323 /* request information on this container */
324 bzero(mi, sizeof(struct aac_mntinfo));
325 mi->Command = VM_NameServe;
326 mi->MntType = FT_FILESYS;
327 mi->MntCount = i;
328 if (aac_sync_fib(sc, ContainerCommand, 0, fib,
329 sizeof(struct aac_mntinfo))) {
330 printf("error probing container %d", i);
331 continue;
332 }
333
334 mir = (struct aac_mntinforesp *)&fib->data[0];
335 /* XXX Need to check if count changed */
336 count = mir->MntRespCount;
337 aac_add_container(sc, mir, 0);
338 i++;
339 } while ((i < count) && (i < AAC_MAX_CONTAINERS));
340
341 aac_release_sync_fib(sc);
342
343 /* poke the bus to actually attach the child devices */
344 if (bus_generic_attach(sc->aac_dev))
345 device_printf(sc->aac_dev, "bus_generic_attach failed\n");
346
347 /* mark the controller up */
348 sc->aac_state &= ~AAC_STATE_SUSPEND;
349
350 /* enable interrupts now */
351 AAC_UNMASK_INTERRUPTS(sc);
352}
353
354/*
355 * Create a device to respresent a new container
356 */
357static void
358aac_add_container(struct aac_softc *sc, struct aac_mntinforesp *mir, int f)
359{
360 struct aac_container *co;
361 device_t child;
362
363 /*
364 * Check container volume type for validity. Note that many of
365 * the possible types may never show up.
366 */
367 if ((mir->Status == ST_OK) && (mir->MntTable[0].VolType != CT_NONE)) {
368 co = (struct aac_container *)malloc(sizeof *co, M_AACBUF,
369 M_NOWAIT | M_ZERO);
370 if (co == NULL)
371 panic("Out of memory?!\n");
372 debug(1, "id %x name '%.16s' size %u type %d",
373 mir->MntTable[0].ObjectId,
374 mir->MntTable[0].FileSystemName,
375 mir->MntTable[0].Capacity, mir->MntTable[0].VolType);
376
377 if ((child = device_add_child(sc->aac_dev, "aacd", -1)) == NULL)
378 device_printf(sc->aac_dev, "device_add_child failed\n");
379 else
380 device_set_ivars(child, co);
381 device_set_desc(child, aac_describe_code(aac_container_types,
382 mir->MntTable[0].VolType));
383 co->co_disk = child;
384 co->co_found = f;
385 bcopy(&mir->MntTable[0], &co->co_mntobj,
386 sizeof(struct aac_mntobj));
387 AAC_LOCK_ACQUIRE(&sc->aac_container_lock);
388 TAILQ_INSERT_TAIL(&sc->aac_container_tqh, co, co_link);
389 AAC_LOCK_RELEASE(&sc->aac_container_lock);
390 }
391}
392
393/*
394 * Free all of the resources associated with (sc)
395 *
396 * Should not be called if the controller is active.
397 */
398void
399aac_free(struct aac_softc *sc)
400{
401
402 debug_called(1);
403
404 /* remove the control device */
405 if (sc->aac_dev_t != NULL)
406 destroy_dev(sc->aac_dev_t);
407
408 /* throw away any FIB buffers, discard the FIB DMA tag */
409 aac_free_commands(sc);
410 if (sc->aac_fib_dmat)
411 bus_dma_tag_destroy(sc->aac_fib_dmat);
412
413 free(sc->aac_commands, M_AACBUF);
414
415 /* destroy the common area */
416 if (sc->aac_common) {
417 bus_dmamap_unload(sc->aac_common_dmat, sc->aac_common_dmamap);
418 bus_dmamem_free(sc->aac_common_dmat, sc->aac_common,
419 sc->aac_common_dmamap);
420 }
421 if (sc->aac_common_dmat)
422 bus_dma_tag_destroy(sc->aac_common_dmat);
423
424 /* disconnect the interrupt handler */
425 if (sc->aac_intr)
426 bus_teardown_intr(sc->aac_dev, sc->aac_irq, sc->aac_intr);
427 if (sc->aac_irq != NULL)
428 bus_release_resource(sc->aac_dev, SYS_RES_IRQ, sc->aac_irq_rid,
429 sc->aac_irq);
430
431 /* destroy data-transfer DMA tag */
432 if (sc->aac_buffer_dmat)
433 bus_dma_tag_destroy(sc->aac_buffer_dmat);
434
435 /* destroy the parent DMA tag */
436 if (sc->aac_parent_dmat)
437 bus_dma_tag_destroy(sc->aac_parent_dmat);
438
439 /* release the register window mapping */
440 if (sc->aac_regs_resource != NULL)
441 bus_release_resource(sc->aac_dev, SYS_RES_MEMORY,
442 sc->aac_regs_rid, sc->aac_regs_resource);
443}
444
445/*
446 * Disconnect from the controller completely, in preparation for unload.
447 */
448int
449aac_detach(device_t dev)
450{
451 struct aac_softc *sc;
452 struct aac_container *co;
453 struct aac_sim *sim;
454 int error;
455
456 debug_called(1);
457
458 sc = device_get_softc(dev);
459
460 if (sc->aac_state & AAC_STATE_OPEN)
461 return(EBUSY);
462
463 /* Remove the child containers */
464 while ((co = TAILQ_FIRST(&sc->aac_container_tqh)) != NULL) {
465 error = device_delete_child(dev, co->co_disk);
466 if (error)
467 return (error);
468 TAILQ_REMOVE(&sc->aac_container_tqh, co, co_link);
469 free(co, M_AACBUF);
470 }
471
472 /* Remove the CAM SIMs */
473 while ((sim = TAILQ_FIRST(&sc->aac_sim_tqh)) != NULL) {
474 TAILQ_REMOVE(&sc->aac_sim_tqh, sim, sim_link);
475 error = device_delete_child(dev, sim->sim_dev);
476 if (error)
477 return (error);
478 free(sim, M_AACBUF);
479 }
480
481 if (sc->aifflags & AAC_AIFFLAGS_RUNNING) {
482 sc->aifflags |= AAC_AIFFLAGS_EXIT;
483 wakeup(sc->aifthread);
484 tsleep(sc->aac_dev, PUSER | PCATCH, "aacdch", 30 * hz);
485 }
486
487 if (sc->aifflags & AAC_AIFFLAGS_RUNNING)
488 panic("Cannot shutdown AIF thread\n");
489
490 if ((error = aac_shutdown(dev)))
491 return(error);
492
493 EVENTHANDLER_DEREGISTER(shutdown_final, sc->eh);
494
495 aac_free(sc);
496
497 return(0);
498}
499
500/*
501 * Bring the controller down to a dormant state and detach all child devices.
502 *
503 * This function is called before detach or system shutdown.
504 *
505 * Note that we can assume that the bioq on the controller is empty, as we won't
506 * allow shutdown if any device is open.
507 */
508int
509aac_shutdown(device_t dev)
510{
511 struct aac_softc *sc;
512 struct aac_fib *fib;
513 struct aac_close_command *cc;
514
515 debug_called(1);
516
517 sc = device_get_softc(dev);
518
519 sc->aac_state |= AAC_STATE_SUSPEND;
520
521 /*
522 * Send a Container shutdown followed by a HostShutdown FIB to the
523 * controller to convince it that we don't want to talk to it anymore.
524 * We've been closed and all I/O completed already
525 */
526 device_printf(sc->aac_dev, "shutting down controller...");
527
528 aac_alloc_sync_fib(sc, &fib, AAC_SYNC_LOCK_FORCE);
529 cc = (struct aac_close_command *)&fib->data[0];
530
531 bzero(cc, sizeof(struct aac_close_command));
532 cc->Command = VM_CloseAll;
533 cc->ContainerId = 0xffffffff;
534 if (aac_sync_fib(sc, ContainerCommand, 0, fib,
535 sizeof(struct aac_close_command)))
536 printf("FAILED.\n");
537 else
538 printf("done\n");
539#if 0
540 else {
541 fib->data[0] = 0;
542 /*
543 * XXX Issuing this command to the controller makes it shut down
544 * but also keeps it from coming back up without a reset of the
545 * PCI bus. This is not desirable if you are just unloading the
546 * driver module with the intent to reload it later.
547 */
548 if (aac_sync_fib(sc, FsaHostShutdown, AAC_FIBSTATE_SHUTDOWN,
549 fib, 1)) {
550 printf("FAILED.\n");
551 } else {
552 printf("done.\n");
553 }
554 }
555#endif
556
557 AAC_MASK_INTERRUPTS(sc);
558
559 return(0);
560}
561
562/*
563 * Bring the controller to a quiescent state, ready for system suspend.
564 */
565int
566aac_suspend(device_t dev)
567{
568 struct aac_softc *sc;
569
570 debug_called(1);
571
572 sc = device_get_softc(dev);
573
574 sc->aac_state |= AAC_STATE_SUSPEND;
575
576 AAC_MASK_INTERRUPTS(sc);
577 return(0);
578}
579
580/*
581 * Bring the controller back to a state ready for operation.
582 */
583int
584aac_resume(device_t dev)
585{
586 struct aac_softc *sc;
587
588 debug_called(1);
589
590 sc = device_get_softc(dev);
591
592 sc->aac_state &= ~AAC_STATE_SUSPEND;
593 AAC_UNMASK_INTERRUPTS(sc);
594 return(0);
595}
596
597/*
598 * Take an interrupt.
599 */
600void
601aac_intr(void *arg)
602{
603 struct aac_softc *sc;
604 u_int16_t reason;
605
606 debug_called(2);
607
608 sc = (struct aac_softc *)arg;
609
610 /*
611 * Read the status register directly. This is faster than taking the
612 * driver lock and reading the queues directly. It also saves having
613 * to turn parts of the driver lock into a spin mutex, which would be
614 * ugly.
615 */
616 reason = AAC_GET_ISTATUS(sc);
617 AAC_CLEAR_ISTATUS(sc, reason);
618
619 /* handle completion processing */
620 if (reason & AAC_DB_RESPONSE_READY)
621 taskqueue_enqueue_fast(taskqueue_fast, &sc->aac_task_complete);
622
623 /* controller wants to talk to us */
624 if (reason & (AAC_DB_PRINTF | AAC_DB_COMMAND_READY)) {
625 /*
626 * XXX Make sure that we don't get fooled by strange messages
627 * that start with a NULL.
628 */
629 if ((reason & AAC_DB_PRINTF) &&
630 (sc->aac_common->ac_printf[0] == 0))
631 sc->aac_common->ac_printf[0] = 32;
632
633 /*
634 * This might miss doing the actual wakeup. However, the
635 * msleep that this is waking up has a timeout, so it will
636 * wake up eventually. AIFs and printfs are low enough
637 * priority that they can handle hanging out for a few seconds
638 * if needed.
639 */
640 wakeup(sc->aifthread);
641 }
642}
643
644/*
645 * Command Processing
646 */
647
648/*
649 * Start as much queued I/O as possible on the controller
650 */
651void
652aac_startio(struct aac_softc *sc)
653{
654 struct aac_command *cm;
655
656 debug_called(2);
657
658 if (sc->flags & AAC_QUEUE_FRZN)
659 return;
660
661 for (;;) {
662 /*
663 * Try to get a command that's been put off for lack of
664 * resources
665 */
666 cm = aac_dequeue_ready(sc);
667
668 /*
669 * Try to build a command off the bio queue (ignore error
670 * return)
671 */
672 if (cm == NULL)
673 aac_bio_command(sc, &cm);
674
675 /* nothing to do? */
676 if (cm == NULL)
677 break;
678
679 /*
680 * Try to give the command to the controller. Any error is
681 * catastrophic since it means that bus_dmamap_load() failed.
682 */
683 if (aac_map_command(cm) != 0)
684 panic("aac: error mapping command %p\n", cm);
685 }
686}
687
688/*
689 * Deliver a command to the controller; allocate controller resources at the
690 * last moment when possible.
691 */
692static int
693aac_map_command(struct aac_command *cm)
694{
695 struct aac_softc *sc;
696 int error;
697
698 debug_called(2);
699
700 sc = cm->cm_sc;
701 error = 0;
702
703 /* don't map more than once */
704 if (cm->cm_flags & AAC_CMD_MAPPED)
705 panic("aac: command %p already mapped", cm);
706
707 if (cm->cm_datalen != 0) {
708 error = bus_dmamap_load(sc->aac_buffer_dmat, cm->cm_datamap,
709 cm->cm_data, cm->cm_datalen,
710 aac_map_command_sg, cm, 0);
711 if (error == EINPROGRESS) {
712 debug(1, "freezing queue\n");
713 sc->flags |= AAC_QUEUE_FRZN;
714 error = 0;
715 }
716 } else {
717 aac_map_command_sg(cm, NULL, 0, 0);
718 }
719 return (error);
720}
721
722/*
723 * Handle notification of one or more FIBs coming from the controller.
724 */
725static void
726aac_command_thread(struct aac_softc *sc)
727{
728 struct aac_fib *fib;
729 u_int32_t fib_size;
730 int size, retval;
731
732 debug_called(2);
733
734 AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
735 sc->aifflags = AAC_AIFFLAGS_RUNNING;
736
737 while ((sc->aifflags & AAC_AIFFLAGS_EXIT) == 0) {
738
739 retval = 0;
740 if ((sc->aifflags & AAC_AIFFLAGS_PENDING) == 0)
741 retval = msleep(sc->aifthread, &sc->aac_io_lock, PRIBIO,
742 "aifthd", AAC_PERIODIC_INTERVAL * hz);
743
744 /*
745 * First see if any FIBs need to be allocated. This needs
746 * to be called without the driver lock because contigmalloc
747 * will grab Giant, and would result in an LOR.
748 */
749 if ((sc->aifflags & AAC_AIFFLAGS_ALLOCFIBS) != 0) {
750 AAC_LOCK_RELEASE(&sc->aac_io_lock);
751 aac_alloc_commands(sc);
752 AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
753 sc->aifflags &= ~AAC_AIFFLAGS_ALLOCFIBS;
754 aac_startio(sc);
755 }
756
757 /*
758 * While we're here, check to see if any commands are stuck.
759 * This is pretty low-priority, so it's ok if it doesn't
760 * always fire.
761 */
762 if (retval == EWOULDBLOCK)
763 aac_timeout(sc);
764
765 /* Check the hardware printf message buffer */
766 if (sc->aac_common->ac_printf[0] != 0)
767 aac_print_printf(sc);
768
769 /* Also check to see if the adapter has a command for us. */
770 while (aac_dequeue_fib(sc, AAC_HOST_NORM_CMD_QUEUE,
771 &fib_size, &fib) == 0) {
772
773 AAC_PRINT_FIB(sc, fib);
774
775 switch (fib->Header.Command) {
776 case AifRequest:
777 aac_handle_aif(sc, fib);
778 break;
779 default:
780 device_printf(sc->aac_dev, "unknown command "
781 "from controller\n");
782 break;
783 }
784
785 if ((fib->Header.XferState == 0) ||
786 (fib->Header.StructType != AAC_FIBTYPE_TFIB))
787 break;
788
789 /* Return the AIF to the controller. */
790 if (fib->Header.XferState & AAC_FIBSTATE_FROMADAP) {
791 fib->Header.XferState |= AAC_FIBSTATE_DONEHOST;
792 *(AAC_FSAStatus*)fib->data = ST_OK;
793
794 /* XXX Compute the Size field? */
795 size = fib->Header.Size;
796 if (size > sizeof(struct aac_fib)) {
797 size = sizeof(struct aac_fib);
798 fib->Header.Size = size;
799 }
800 /*
801 * Since we did not generate this command, it
802 * cannot go through the normal
803 * enqueue->startio chain.
804 */
805 aac_enqueue_response(sc,
806 AAC_ADAP_NORM_RESP_QUEUE,
807 fib);
808 }
809 }
810 }
811 sc->aifflags &= ~AAC_AIFFLAGS_RUNNING;
812 AAC_LOCK_RELEASE(&sc->aac_io_lock);
813 wakeup(sc->aac_dev);
814
815 mtx_lock(&Giant);
816 kthread_exit(0);
817}
818
819/*
820 * Process completed commands.
821 */
822static void
823aac_complete(void *context, int pending)
824{
825 struct aac_softc *sc;
826 struct aac_command *cm;
827 struct aac_fib *fib;
828 u_int32_t fib_size;
829
830 debug_called(2);
831
832 sc = (struct aac_softc *)context;
833
834 AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
835
836 /* pull completed commands off the queue */
837 for (;;) {
838 /* look for completed FIBs on our queue */
839 if (aac_dequeue_fib(sc, AAC_HOST_NORM_RESP_QUEUE, &fib_size,
840 &fib))
841 break; /* nothing to do */
842
843 /* get the command, unmap and hand off for processing */
844 cm = sc->aac_commands + fib->Header.SenderData;
845 if (cm == NULL) {
846 AAC_PRINT_FIB(sc, fib);
847 break;
848 }
849
850 aac_remove_busy(cm);
851 aac_unmap_command(cm);
852 cm->cm_flags |= AAC_CMD_COMPLETED;
853
854 /* is there a completion handler? */
855 if (cm->cm_complete != NULL) {
856 cm->cm_complete(cm);
857 } else {
858 /* assume that someone is sleeping on this command */
859 wakeup(cm);
860 }
861 }
862
863 /* see if we can start some more I/O */
864 sc->flags &= ~AAC_QUEUE_FRZN;
865 aac_startio(sc);
866
867 AAC_LOCK_RELEASE(&sc->aac_io_lock);
868}
869
870/*
871 * Handle a bio submitted from a disk device.
872 */
873void
874aac_submit_bio(struct bio *bp)
875{
876 struct aac_disk *ad;
877 struct aac_softc *sc;
878
879 debug_called(2);
880
881 ad = (struct aac_disk *)bp->bio_disk->d_drv1;
882 sc = ad->ad_controller;
883
884 /* queue the BIO and try to get some work done */
885 aac_enqueue_bio(sc, bp);
886 aac_startio(sc);
887}
888
889/*
890 * Get a bio and build a command to go with it.
891 */
892static int
893aac_bio_command(struct aac_softc *sc, struct aac_command **cmp)
894{
895 struct aac_command *cm;
896 struct aac_fib *fib;
897 struct aac_disk *ad;
898 struct bio *bp;
899
900 debug_called(2);
901
902 /* get the resources we will need */
903 cm = NULL;
904 bp = NULL;
905 if (aac_alloc_command(sc, &cm)) /* get a command */
906 goto fail;
907 if ((bp = aac_dequeue_bio(sc)) == NULL)
908 goto fail;
909
910 /* fill out the command */
911 cm->cm_data = (void *)bp->bio_data;
912 cm->cm_datalen = bp->bio_bcount;
913 cm->cm_complete = aac_bio_complete;
914 cm->cm_private = bp;
915 cm->cm_timestamp = time_second;
916 cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE;
917
918 /* build the FIB */
919 fib = cm->cm_fib;
920 fib->Header.Size = sizeof(struct aac_fib_header);
921 fib->Header.XferState =
922 AAC_FIBSTATE_HOSTOWNED |
923 AAC_FIBSTATE_INITIALISED |
924 AAC_FIBSTATE_EMPTY |
925 AAC_FIBSTATE_FROMHOST |
926 AAC_FIBSTATE_REXPECTED |
927 AAC_FIBSTATE_NORM |
928 AAC_FIBSTATE_ASYNC |
929 AAC_FIBSTATE_FAST_RESPONSE;
930
931 /* build the read/write request */
932 ad = (struct aac_disk *)bp->bio_disk->d_drv1;
933
934 if ((sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
935 fib->Header.Command = ContainerCommand;
936 if (bp->bio_cmd == BIO_READ) {
937 struct aac_blockread *br;
938 br = (struct aac_blockread *)&fib->data[0];
939 br->Command = VM_CtBlockRead;
940 br->ContainerId = ad->ad_container->co_mntobj.ObjectId;
941 br->BlockNumber = bp->bio_pblkno;
942 br->ByteCount = bp->bio_bcount;
943 fib->Header.Size += sizeof(struct aac_blockread);
944 cm->cm_sgtable = &br->SgMap;
945 cm->cm_flags |= AAC_CMD_DATAIN;
946 } else {
947 struct aac_blockwrite *bw;
948 bw = (struct aac_blockwrite *)&fib->data[0];
949 bw->Command = VM_CtBlockWrite;
950 bw->ContainerId = ad->ad_container->co_mntobj.ObjectId;
951 bw->BlockNumber = bp->bio_pblkno;
952 bw->ByteCount = bp->bio_bcount;
953 bw->Stable = CUNSTABLE;
954 fib->Header.Size += sizeof(struct aac_blockwrite);
955 cm->cm_flags |= AAC_CMD_DATAOUT;
956 cm->cm_sgtable = &bw->SgMap;
957 }
958 } else {
959 fib->Header.Command = ContainerCommand64;
960 if (bp->bio_cmd == BIO_READ) {
961 struct aac_blockread64 *br;
962 br = (struct aac_blockread64 *)&fib->data[0];
963 br->Command = VM_CtHostRead64;
964 br->ContainerId = ad->ad_container->co_mntobj.ObjectId;
965 br->SectorCount = bp->bio_bcount / AAC_BLOCK_SIZE;
966 br->BlockNumber = bp->bio_pblkno;
967 br->Pad = 0;
968 br->Flags = 0;
969 fib->Header.Size += sizeof(struct aac_blockread64);
970 cm->cm_flags |= AAC_CMD_DATAOUT;
971 (struct aac_sg_table64 *)cm->cm_sgtable = &br->SgMap64;
972 } else {
973 struct aac_blockwrite64 *bw;
974 bw = (struct aac_blockwrite64 *)&fib->data[0];
975 bw->Command = VM_CtHostWrite64;
976 bw->ContainerId = ad->ad_container->co_mntobj.ObjectId;
977 bw->SectorCount = bp->bio_bcount / AAC_BLOCK_SIZE;
978 bw->BlockNumber = bp->bio_pblkno;
979 bw->Pad = 0;
980 bw->Flags = 0;
981 fib->Header.Size += sizeof(struct aac_blockwrite64);
982 cm->cm_flags |= AAC_CMD_DATAIN;
983 (struct aac_sg_table64 *)cm->cm_sgtable = &bw->SgMap64;
984 }
985 }
986
987 *cmp = cm;
988 return(0);
989
990fail:
991 if (bp != NULL)
992 aac_enqueue_bio(sc, bp);
993 if (cm != NULL)
994 aac_release_command(cm);
995 return(ENOMEM);
996}
997
998/*
999 * Handle a bio-instigated command that has been completed.
1000 */
1001static void
1002aac_bio_complete(struct aac_command *cm)
1003{
1004 struct aac_blockread_response *brr;
1005 struct aac_blockwrite_response *bwr;
1006 struct bio *bp;
1007 AAC_FSAStatus status;
1008
1009 /* fetch relevant status and then release the command */
1010 bp = (struct bio *)cm->cm_private;
1011 if (bp->bio_cmd == BIO_READ) {
1012 brr = (struct aac_blockread_response *)&cm->cm_fib->data[0];
1013 status = brr->Status;
1014 } else {
1015 bwr = (struct aac_blockwrite_response *)&cm->cm_fib->data[0];
1016 status = bwr->Status;
1017 }
1018 aac_release_command(cm);
1019
1020 /* fix up the bio based on status */
1021 if (status == ST_OK) {
1022 bp->bio_resid = 0;
1023 } else {
1024 bp->bio_error = EIO;
1025 bp->bio_flags |= BIO_ERROR;
1026 /* pass an error string out to the disk layer */
1027 bp->bio_driver1 = aac_describe_code(aac_command_status_table,
1028 status);
1029 }
1030 aac_biodone(bp);
1031}
1032
1033/*
1034 * Submit a command to the controller, return when it completes.
1035 * XXX This is very dangerous! If the card has gone out to lunch, we could
1036 * be stuck here forever. At the same time, signals are not caught
1037 * because there is a risk that a signal could wakeup the tsleep before
1038 * the card has a chance to complete the command. The passed in timeout
1039 * is ignored for the same reason. Since there is no way to cancel a
1040 * command in progress, we should probably create a 'dead' queue where
1041 * commands go that have been interrupted/timed-out/etc, that keeps them
1042 * out of the free pool. That way, if the card is just slow, it won't
1043 * spam the memory of a command that has been recycled.
1044 */
1045static int
1046aac_wait_command(struct aac_command *cm, int timeout)
1047{
1048 struct aac_softc *sc;
1049 int error = 0;
1050
1051 debug_called(2);
1052
1053 sc = cm->cm_sc;
1054
1055 /* Put the command on the ready queue and get things going */
1056 cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE;
1057 aac_enqueue_ready(cm);
1058 aac_startio(sc);
1059 while (!(cm->cm_flags & AAC_CMD_COMPLETED) && (error != EWOULDBLOCK)) {
1060 error = msleep(cm, &sc->aac_io_lock, PRIBIO, "aacwait", 0);
1061 }
1062 return(error);
1063}
1064
1065/*
1066 *Command Buffer Management
1067 */
1068
1069/*
1070 * Allocate a command.
1071 */
1072int
1073aac_alloc_command(struct aac_softc *sc, struct aac_command **cmp)
1074{
1075 struct aac_command *cm;
1076
1077 debug_called(3);
1078
1079 if ((cm = aac_dequeue_free(sc)) == NULL) {
1080 if (sc->total_fibs < sc->aac_max_fibs) {
1081 sc->aifflags |= AAC_AIFFLAGS_ALLOCFIBS;
1082 wakeup(sc->aifthread);
1083 }
1084 return (EBUSY);
1085 }
1086
1087 *cmp = cm;
1088 return(0);
1089}
1090
1091/*
1092 * Release a command back to the freelist.
1093 */
1094void
1095aac_release_command(struct aac_command *cm)
1096{
1097 debug_called(3);
1098
1099 /* (re)initialise the command/FIB */
1100 cm->cm_sgtable = NULL;
1101 cm->cm_flags = 0;
1102 cm->cm_complete = NULL;
1103 cm->cm_private = NULL;
1104 cm->cm_fib->Header.XferState = AAC_FIBSTATE_EMPTY;
1105 cm->cm_fib->Header.StructType = AAC_FIBTYPE_TFIB;
1106 cm->cm_fib->Header.Flags = 0;
1107 cm->cm_fib->Header.SenderSize = sizeof(struct aac_fib);
1108
1109 /*
1110 * These are duplicated in aac_start to cover the case where an
1111 * intermediate stage may have destroyed them. They're left
1112 * initialised here for debugging purposes only.
1113 */
1114 cm->cm_fib->Header.ReceiverFibAddress = (u_int32_t)cm->cm_fibphys;
1115 cm->cm_fib->Header.SenderData = 0;
1116
1117 aac_enqueue_free(cm);
1118}
1119
1120/*
1121 * Map helper for command/FIB allocation.
1122 */
1123static void
1124aac_map_command_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1125{
1126 uint32_t *fibphys;
1127
1128 fibphys = (uint32_t *)arg;
1129
1130 debug_called(3);
1131
1132 *fibphys = segs[0].ds_addr;
1133}
1134
1135/*
1136 * Allocate and initialise commands/FIBs for this adapter.
1137 */
1138static int
1139aac_alloc_commands(struct aac_softc *sc)
1140{
1141 struct aac_command *cm;
1142 struct aac_fibmap *fm;
1143 uint32_t fibphys;
1144 int i, error;
1145
1146 debug_called(2);
1147
1148 if (sc->total_fibs + AAC_FIB_COUNT > sc->aac_max_fibs)
1149 return (ENOMEM);
1150
1151 fm = malloc(sizeof(struct aac_fibmap), M_AACBUF, M_NOWAIT|M_ZERO);
1152 if (fm == NULL)
1153 return (ENOMEM);
1154
1155 /* allocate the FIBs in DMAable memory and load them */
1156 if (bus_dmamem_alloc(sc->aac_fib_dmat, (void **)&fm->aac_fibs,
1157 BUS_DMA_NOWAIT, &fm->aac_fibmap)) {
1158 device_printf(sc->aac_dev,
1159 "Not enough contiguous memory available.\n");
1160 free(fm, M_AACBUF);
1161 return (ENOMEM);
1162 }
1163
1164 /* Ignore errors since this doesn't bounce */
1165 (void)bus_dmamap_load(sc->aac_fib_dmat, fm->aac_fibmap, fm->aac_fibs,
1166 AAC_FIB_COUNT * sizeof(struct aac_fib),
1167 aac_map_command_helper, &fibphys, 0);
1168
1169 /* initialise constant fields in the command structure */
1170 AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
1171 bzero(fm->aac_fibs, AAC_FIB_COUNT * sizeof(struct aac_fib));
1172 for (i = 0; i < AAC_FIB_COUNT; i++) {
1173 cm = sc->aac_commands + sc->total_fibs;
1174 fm->aac_commands = cm;
1175 cm->cm_sc = sc;
1176 cm->cm_fib = fm->aac_fibs + i;
1177 cm->cm_fibphys = fibphys + (i * sizeof(struct aac_fib));
1178 cm->cm_index = sc->total_fibs;
1179
1180 if ((error = bus_dmamap_create(sc->aac_buffer_dmat, 0,
1181 &cm->cm_datamap)) == 0)
1182 aac_release_command(cm);
1183 else
1184 break;
1185 sc->total_fibs++;
1186 }
1187
1188 if (i > 0) {
1189 TAILQ_INSERT_TAIL(&sc->aac_fibmap_tqh, fm, fm_link);
1190 debug(1, "total_fibs= %d\n", sc->total_fibs);
1191 AAC_LOCK_RELEASE(&sc->aac_io_lock);
1192 return (0);
1193 }
1194
1195 AAC_LOCK_RELEASE(&sc->aac_io_lock);
1196 bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap);
1197 bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap);
1198 free(fm, M_AACBUF);
1199 return (ENOMEM);
1200}
1201
1202/*
1203 * Free FIBs owned by this adapter.
1204 */
1205static void
1206aac_free_commands(struct aac_softc *sc)
1207{
1208 struct aac_fibmap *fm;
1209 struct aac_command *cm;
1210 int i;
1211
1212 debug_called(1);
1213
1214 while ((fm = TAILQ_FIRST(&sc->aac_fibmap_tqh)) != NULL) {
1215
1216 TAILQ_REMOVE(&sc->aac_fibmap_tqh, fm, fm_link);
1217 /*
1218 * We check against total_fibs to handle partially
1219 * allocated blocks.
1220 */
1221 for (i = 0; i < AAC_FIB_COUNT && sc->total_fibs--; i++) {
1222 cm = fm->aac_commands + i;
1223 bus_dmamap_destroy(sc->aac_buffer_dmat, cm->cm_datamap);
1224 }
1225 bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap);
1226 bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap);
1227 free(fm, M_AACBUF);
1228 }
1229}
1230
1231/*
1232 * Command-mapping helper function - populate this command's s/g table.
1233 */
1234static void
1235aac_map_command_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1236{
1237 struct aac_softc *sc;
1238 struct aac_command *cm;
1239 struct aac_fib *fib;
1240 int i;
1241
1242 debug_called(3);
1243
1244 cm = (struct aac_command *)arg;
1245 sc = cm->cm_sc;
1246 fib = cm->cm_fib;
1247
1248 /* copy into the FIB */
1249 if (cm->cm_sgtable != NULL) {
1250 if ((cm->cm_sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
1251 struct aac_sg_table *sg;
1252 sg = cm->cm_sgtable;
1253 sg->SgCount = nseg;
1254 for (i = 0; i < nseg; i++) {
1255 sg->SgEntry[i].SgAddress = segs[i].ds_addr;
1256 sg->SgEntry[i].SgByteCount = segs[i].ds_len;
1257 }
1258 /* update the FIB size for the s/g count */
1259 fib->Header.Size += nseg * sizeof(struct aac_sg_entry);
1260 } else {
1261 struct aac_sg_table64 *sg;
1262 sg = (struct aac_sg_table64 *)cm->cm_sgtable;
1263 sg->SgCount = nseg;
1264 for (i = 0; i < nseg; i++) {
1265 sg->SgEntry64[i].SgAddress = segs[i].ds_addr;
1266 sg->SgEntry64[i].SgByteCount = segs[i].ds_len;
1267 }
1268 /* update the FIB size for the s/g count */
1269 fib->Header.Size += nseg*sizeof(struct aac_sg_entry64);
1270 }
1271 }
1272
1273 /* Fix up the address values in the FIB. Use the command array index
1274 * instead of a pointer since these fields are only 32 bits. Shift
1275 * the SenderFibAddress over to make room for the fast response bit.
1276 */
1277 cm->cm_fib->Header.SenderFibAddress = (cm->cm_index << 1);
1278 cm->cm_fib->Header.ReceiverFibAddress = cm->cm_fibphys;
1279
1280 /* save a pointer to the command for speedy reverse-lookup */
1281 cm->cm_fib->Header.SenderData = cm->cm_index;
1282
1283 if (cm->cm_flags & AAC_CMD_DATAIN)
1284 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1285 BUS_DMASYNC_PREREAD);
1286 if (cm->cm_flags & AAC_CMD_DATAOUT)
1287 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1288 BUS_DMASYNC_PREWRITE);
1289 cm->cm_flags |= AAC_CMD_MAPPED;
1290
1291 /* put the FIB on the outbound queue */
1292 if (aac_enqueue_fib(sc, cm->cm_queue, cm) == EBUSY) {
1293 aac_unmap_command(cm);
1294 aac_requeue_ready(cm);
1295 }
1296
1297 return;
1298}
1299
1300/*
1301 * Unmap a command from controller-visible space.
1302 */
1303static void
1304aac_unmap_command(struct aac_command *cm)
1305{
1306 struct aac_softc *sc;
1307
1308 debug_called(2);
1309
1310 sc = cm->cm_sc;
1311
1312 if (!(cm->cm_flags & AAC_CMD_MAPPED))
1313 return;
1314
1315 if (cm->cm_datalen != 0) {
1316 if (cm->cm_flags & AAC_CMD_DATAIN)
1317 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1318 BUS_DMASYNC_POSTREAD);
1319 if (cm->cm_flags & AAC_CMD_DATAOUT)
1320 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1321 BUS_DMASYNC_POSTWRITE);
1322
1323 bus_dmamap_unload(sc->aac_buffer_dmat, cm->cm_datamap);
1324 }
1325 cm->cm_flags &= ~AAC_CMD_MAPPED;
1326}
1327
1328/*
1329 * Hardware Interface
1330 */
1331
1332/*
1333 * Initialise the adapter.
1334 */
1335static void
1336aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1337{
1338 struct aac_softc *sc;
1339
1340 debug_called(1);
1341
1342 sc = (struct aac_softc *)arg;
1343
1344 sc->aac_common_busaddr = segs[0].ds_addr;
1345}
1346
1347static int
1348aac_check_firmware(struct aac_softc *sc)
1349{
1350 u_int32_t major, minor, options;
1351
1352 debug_called(1);
1353
1354 /*
1355 * Retrieve the firmware version numbers. Dell PERC2/QC cards with
1356 * firmware version 1.x are not compatible with this driver.
1357 */
1358 if (sc->flags & AAC_FLAGS_PERC2QC) {
1359 if (aac_sync_command(sc, AAC_MONKER_GETKERNVER, 0, 0, 0, 0,
1360 NULL)) {
1361 device_printf(sc->aac_dev,
1362 "Error reading firmware version\n");
1363 return (EIO);
1364 }
1365
1366 /* These numbers are stored as ASCII! */
1367 major = (AAC_GET_MAILBOX(sc, 1) & 0xff) - 0x30;
1368 minor = (AAC_GET_MAILBOX(sc, 2) & 0xff) - 0x30;
1369 if (major == 1) {
1370 device_printf(sc->aac_dev,
1371 "Firmware version %d.%d is not supported.\n",
1372 major, minor);
1373 return (EINVAL);
1374 }
1375 }
1376
1377 /*
1378 * Retrieve the capabilities/supported options word so we know what
1379 * work-arounds to enable.
1380 */
1381 if (aac_sync_command(sc, AAC_MONKER_GETINFO, 0, 0, 0, 0, NULL)) {
1382 device_printf(sc->aac_dev, "RequestAdapterInfo failed\n");
1383 return (EIO);
1384 }
1385 options = AAC_GET_MAILBOX(sc, 1);
1386 sc->supported_options = options;
1387
1388 if ((options & AAC_SUPPORTED_4GB_WINDOW) != 0 &&
1389 (sc->flags & AAC_FLAGS_NO4GB) == 0)
1390 sc->flags |= AAC_FLAGS_4GB_WINDOW;
1391 if (options & AAC_SUPPORTED_NONDASD)
1392 sc->flags |= AAC_FLAGS_ENABLE_CAM;
1393 if ((options & AAC_SUPPORTED_SGMAP_HOST64) != 0
1394 && (sizeof(bus_addr_t) > 4)) {
1395 device_printf(sc->aac_dev, "Enabling 64-bit address support\n");
1396 sc->flags |= AAC_FLAGS_SG_64BIT;
1397 }
1398
1399 /* Check for broken hardware that does a lower number of commands */
1400 if ((sc->flags & AAC_FLAGS_256FIBS) == 0)
1401 sc->aac_max_fibs = AAC_MAX_FIBS;
1402 else
1403 sc->aac_max_fibs = 256;
1404
1405 return (0);
1406}
1407
1408static int
1409aac_init(struct aac_softc *sc)
1410{
1411 struct aac_adapter_init *ip;
1412 time_t then;
1413 u_int32_t code, qoffset;
1414 int error;
1415
1416 debug_called(1);
1417
1418 /*
1419 * First wait for the adapter to come ready.
1420 */
1421 then = time_second;
1422 do {
1423 code = AAC_GET_FWSTATUS(sc);
1424 if (code & AAC_SELF_TEST_FAILED) {
1425 device_printf(sc->aac_dev, "FATAL: selftest failed\n");
1426 return(ENXIO);
1427 }
1428 if (code & AAC_KERNEL_PANIC) {
1429 device_printf(sc->aac_dev,
1430 "FATAL: controller kernel panic\n");
1431 return(ENXIO);
1432 }
1433 if (time_second > (then + AAC_BOOT_TIMEOUT)) {
1434 device_printf(sc->aac_dev,
1435 "FATAL: controller not coming ready, "
1436 "status %x\n", code);
1437 return(ENXIO);
1438 }
1439 } while (!(code & AAC_UP_AND_RUNNING));
1440
1441 error = ENOMEM;
1442 /*
1443 * Create DMA tag for mapping buffers into controller-addressable space.
1444 */
1445 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
1446 1, 0, /* algnmnt, boundary */
1447 (sc->flags & AAC_FLAGS_SG_64BIT) ?
1448 BUS_SPACE_MAXADDR :
1449 BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
1450 BUS_SPACE_MAXADDR, /* highaddr */
1451 NULL, NULL, /* filter, filterarg */
1452 MAXBSIZE, /* maxsize */
1453 AAC_MAXSGENTRIES, /* nsegments */
1454 MAXBSIZE, /* maxsegsize */
1455 BUS_DMA_ALLOCNOW, /* flags */
1456 busdma_lock_mutex, /* lockfunc */
1457 &sc->aac_io_lock, /* lockfuncarg */
1458 &sc->aac_buffer_dmat)) {
1459 device_printf(sc->aac_dev, "can't allocate buffer DMA tag\n");
1460 goto out;
1461 }
1462
1463 /*
1464 * Create DMA tag for mapping FIBs into controller-addressable space..
1465 */
1466 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
1467 1, 0, /* algnmnt, boundary */
1468 (sc->flags & AAC_FLAGS_4GB_WINDOW) ?
1469 BUS_SPACE_MAXADDR_32BIT :
1470 0x7fffffff, /* lowaddr */
1471 BUS_SPACE_MAXADDR, /* highaddr */
1472 NULL, NULL, /* filter, filterarg */
1473 AAC_FIB_COUNT *
1474 sizeof(struct aac_fib), /* maxsize */
1475 1, /* nsegments */
1476 AAC_FIB_COUNT *
1477 sizeof(struct aac_fib), /* maxsegsize */
1478 BUS_DMA_ALLOCNOW, /* flags */
1479 NULL, NULL, /* No locking needed */
1480 &sc->aac_fib_dmat)) {
1481 device_printf(sc->aac_dev, "can't allocate FIB DMA tag\n");;
1482 goto out;
1483 }
1484
1485 /*
1486 * Create DMA tag for the common structure and allocate it.
1487 */
1488 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
1489 1, 0, /* algnmnt, boundary */
1490 (sc->flags & AAC_FLAGS_4GB_WINDOW) ?
1491 BUS_SPACE_MAXADDR_32BIT :
1492 0x7fffffff, /* lowaddr */
1493 BUS_SPACE_MAXADDR, /* highaddr */
1494 NULL, NULL, /* filter, filterarg */
1495 8192 + sizeof(struct aac_common), /* maxsize */
1496 1, /* nsegments */
1497 BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
1498 BUS_DMA_ALLOCNOW, /* flags */
1499 NULL, NULL, /* No locking needed */
1500 &sc->aac_common_dmat)) {
1501 device_printf(sc->aac_dev,
1502 "can't allocate common structure DMA tag\n");
1503 goto out;
1504 }
1505 if (bus_dmamem_alloc(sc->aac_common_dmat, (void **)&sc->aac_common,
1506 BUS_DMA_NOWAIT, &sc->aac_common_dmamap)) {
1507 device_printf(sc->aac_dev, "can't allocate common structure\n");
1508 goto out;
1509 }
1510
1511 /*
1512 * Work around a bug in the 2120 and 2200 that cannot DMA commands
1513 * below address 8192 in physical memory.
1514 * XXX If the padding is not needed, can it be put to use instead
1515 * of ignored?
1516 */
1517 (void)bus_dmamap_load(sc->aac_common_dmat, sc->aac_common_dmamap,
1518 sc->aac_common, 8192 + sizeof(*sc->aac_common),
1519 aac_common_map, sc, 0);
1520
1521 if (sc->aac_common_busaddr < 8192) {
1522 (uint8_t *)sc->aac_common += 8192;
1523 sc->aac_common_busaddr += 8192;
1524 }
1525 bzero(sc->aac_common, sizeof(*sc->aac_common));
1526
1527 /* Allocate some FIBs and associated command structs */
1528 TAILQ_INIT(&sc->aac_fibmap_tqh);
1529 sc->aac_commands = malloc(AAC_MAX_FIBS * sizeof(struct aac_command),
1530 M_AACBUF, M_WAITOK|M_ZERO);
1531 while (sc->total_fibs < AAC_PREALLOCATE_FIBS) {
1532 if (aac_alloc_commands(sc) != 0)
1533 break;
1534 }
1535 if (sc->total_fibs == 0)
1536 goto out;
1537
1538 /*
1539 * Fill in the init structure. This tells the adapter about the
1540 * physical location of various important shared data structures.
1541 */
1542 ip = &sc->aac_common->ac_init;
1543 ip->InitStructRevision = AAC_INIT_STRUCT_REVISION;
1544 ip->MiniPortRevision = AAC_INIT_STRUCT_MINIPORT_REVISION;
1545
1546 ip->AdapterFibsPhysicalAddress = sc->aac_common_busaddr +
1547 offsetof(struct aac_common, ac_fibs);
1548 ip->AdapterFibsVirtualAddress = 0;
1549 ip->AdapterFibsSize = AAC_ADAPTER_FIBS * sizeof(struct aac_fib);
1550 ip->AdapterFibAlign = sizeof(struct aac_fib);
1551
1552 ip->PrintfBufferAddress = sc->aac_common_busaddr +
1553 offsetof(struct aac_common, ac_printf);
1554 ip->PrintfBufferSize = AAC_PRINTF_BUFSIZE;
1555
1556 /*
1557 * The adapter assumes that pages are 4K in size, except on some
1558 * broken firmware versions that do the page->byte conversion twice,
1559 * therefore 'assuming' that this value is in 16MB units (2^24).
1560 * Round up since the granularity is so high.
1561 */
1562 ip->HostPhysMemPages = ctob(physmem) / AAC_PAGE_SIZE;
1563 if (sc->flags & AAC_FLAGS_BROKEN_MEMMAP) {
1564 ip->HostPhysMemPages =
1565 (ip->HostPhysMemPages + AAC_PAGE_SIZE) / AAC_PAGE_SIZE;
1566 }
1567 ip->HostElapsedSeconds = time_second; /* reset later if invalid */
1568
1569 /*
1570 * Initialise FIB queues. Note that it appears that the layout of the
1571 * indexes and the segmentation of the entries may be mandated by the
1572 * adapter, which is only told about the base of the queue index fields.
1573 *
1574 * The initial values of the indices are assumed to inform the adapter
1575 * of the sizes of the respective queues, and theoretically it could
1576 * work out the entire layout of the queue structures from this. We
1577 * take the easy route and just lay this area out like everyone else
1578 * does.
1579 *
1580 * The Linux driver uses a much more complex scheme whereby several
1581 * header records are kept for each queue. We use a couple of generic
1582 * list manipulation functions which 'know' the size of each list by
1583 * virtue of a table.
1584 */
1585 qoffset = offsetof(struct aac_common, ac_qbuf) + AAC_QUEUE_ALIGN;
1586 qoffset &= ~(AAC_QUEUE_ALIGN - 1);
1587 sc->aac_queues =
1588 (struct aac_queue_table *)((uintptr_t)sc->aac_common + qoffset);
1589 ip->CommHeaderAddress = sc->aac_common_busaddr + qoffset;
1590
1591 sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1592 AAC_HOST_NORM_CMD_ENTRIES;
1593 sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1594 AAC_HOST_NORM_CMD_ENTRIES;
1595 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1596 AAC_HOST_HIGH_CMD_ENTRIES;
1597 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1598 AAC_HOST_HIGH_CMD_ENTRIES;
1599 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1600 AAC_ADAP_NORM_CMD_ENTRIES;
1601 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1602 AAC_ADAP_NORM_CMD_ENTRIES;
1603 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1604 AAC_ADAP_HIGH_CMD_ENTRIES;
1605 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1606 AAC_ADAP_HIGH_CMD_ENTRIES;
1607 sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1608 AAC_HOST_NORM_RESP_ENTRIES;
1609 sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1610 AAC_HOST_NORM_RESP_ENTRIES;
1611 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1612 AAC_HOST_HIGH_RESP_ENTRIES;
1613 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1614 AAC_HOST_HIGH_RESP_ENTRIES;
1615 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1616 AAC_ADAP_NORM_RESP_ENTRIES;
1617 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1618 AAC_ADAP_NORM_RESP_ENTRIES;
1619 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1620 AAC_ADAP_HIGH_RESP_ENTRIES;
1621 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1622 AAC_ADAP_HIGH_RESP_ENTRIES;
1623 sc->aac_qentries[AAC_HOST_NORM_CMD_QUEUE] =
1624 &sc->aac_queues->qt_HostNormCmdQueue[0];
1625 sc->aac_qentries[AAC_HOST_HIGH_CMD_QUEUE] =
1626 &sc->aac_queues->qt_HostHighCmdQueue[0];
1627 sc->aac_qentries[AAC_ADAP_NORM_CMD_QUEUE] =
1628 &sc->aac_queues->qt_AdapNormCmdQueue[0];
1629 sc->aac_qentries[AAC_ADAP_HIGH_CMD_QUEUE] =
1630 &sc->aac_queues->qt_AdapHighCmdQueue[0];
1631 sc->aac_qentries[AAC_HOST_NORM_RESP_QUEUE] =
1632 &sc->aac_queues->qt_HostNormRespQueue[0];
1633 sc->aac_qentries[AAC_HOST_HIGH_RESP_QUEUE] =
1634 &sc->aac_queues->qt_HostHighRespQueue[0];
1635 sc->aac_qentries[AAC_ADAP_NORM_RESP_QUEUE] =
1636 &sc->aac_queues->qt_AdapNormRespQueue[0];
1637 sc->aac_qentries[AAC_ADAP_HIGH_RESP_QUEUE] =
1638 &sc->aac_queues->qt_AdapHighRespQueue[0];
1639
1640 /*
1641 * Do controller-type-specific initialisation
1642 */
1643 switch (sc->aac_hwif) {
1644 case AAC_HWIF_I960RX:
1645 AAC_SETREG4(sc, AAC_RX_ODBR, ~0);
1646 break;
1647 }
1648
1649 /*
1650 * Give the init structure to the controller.
1651 */
1652 if (aac_sync_command(sc, AAC_MONKER_INITSTRUCT,
1653 sc->aac_common_busaddr +
1654 offsetof(struct aac_common, ac_init), 0, 0, 0,
1655 NULL)) {
1656 device_printf(sc->aac_dev,
1657 "error establishing init structure\n");
1658 error = EIO;
1659 goto out;
1660 }
1661
1662 error = 0;
1663out:
1664 return(error);
1665}
1666
1667/*
1668 * Send a synchronous command to the controller and wait for a result.
1669 */
1670static int
1671aac_sync_command(struct aac_softc *sc, u_int32_t command,
1672 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3,
1673 u_int32_t *sp)
1674{
1675 time_t then;
1676 u_int32_t status;
1677
1678 debug_called(3);
1679
1680 /* populate the mailbox */
1681 AAC_SET_MAILBOX(sc, command, arg0, arg1, arg2, arg3);
1682
1683 /* ensure the sync command doorbell flag is cleared */
1684 AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND);
1685
1686 /* then set it to signal the adapter */
1687 AAC_QNOTIFY(sc, AAC_DB_SYNC_COMMAND);
1688
1689 /* spin waiting for the command to complete */
1690 then = time_second;
1691 do {
1692 if (time_second > (then + AAC_IMMEDIATE_TIMEOUT)) {
1693 debug(1, "timed out");
1694 return(EIO);
1695 }
1696 } while (!(AAC_GET_ISTATUS(sc) & AAC_DB_SYNC_COMMAND));
1697
1698 /* clear the completion flag */
1699 AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND);
1700
1701 /* get the command status */
1702 status = AAC_GET_MAILBOX(sc, 0);
1703 if (sp != NULL)
1704 *sp = status;
1705 return(0);
1706}
1707
1708/*
1709 * Grab the sync fib area.
1710 */
1711int
1712aac_alloc_sync_fib(struct aac_softc *sc, struct aac_fib **fib, int flags)
1713{
1714
1715 /*
1716 * If the force flag is set, the system is shutting down, or in
1717 * trouble. Ignore the mutex.
1718 */
1719 if (!(flags & AAC_SYNC_LOCK_FORCE))
1720 AAC_LOCK_ACQUIRE(&sc->aac_sync_lock);
1721
1722 *fib = &sc->aac_common->ac_sync_fib;
1723
1724 return (1);
1725}
1726
1727/*
1728 * Release the sync fib area.
1729 */
1730void
1731aac_release_sync_fib(struct aac_softc *sc)
1732{
1733
1734 AAC_LOCK_RELEASE(&sc->aac_sync_lock);
1735}
1736
1737/*
1738 * Send a synchronous FIB to the controller and wait for a result.
1739 */
1740int
1741aac_sync_fib(struct aac_softc *sc, u_int32_t command, u_int32_t xferstate,
1742 struct aac_fib *fib, u_int16_t datasize)
1743{
1744 debug_called(3);
1745
1746 if (datasize > AAC_FIB_DATASIZE)
1747 return(EINVAL);
1748
1749 /*
1750 * Set up the sync FIB
1751 */
1752 fib->Header.XferState = AAC_FIBSTATE_HOSTOWNED |
1753 AAC_FIBSTATE_INITIALISED |
1754 AAC_FIBSTATE_EMPTY;
1755 fib->Header.XferState |= xferstate;
1756 fib->Header.Command = command;
1757 fib->Header.StructType = AAC_FIBTYPE_TFIB;
1758 fib->Header.Size = sizeof(struct aac_fib) + datasize;
1759 fib->Header.SenderSize = sizeof(struct aac_fib);
1760 fib->Header.SenderFibAddress = 0; /* Not needed */
1761 fib->Header.ReceiverFibAddress = sc->aac_common_busaddr +
1762 offsetof(struct aac_common,
1763 ac_sync_fib);
1764
1765 /*
1766 * Give the FIB to the controller, wait for a response.
1767 */
1768 if (aac_sync_command(sc, AAC_MONKER_SYNCFIB,
1769 fib->Header.ReceiverFibAddress, 0, 0, 0, NULL)) {
1770 debug(2, "IO error");
1771 return(EIO);
1772 }
1773
1774 return (0);
1775}
1776
1777/*
1778 * Adapter-space FIB queue manipulation
1779 *
1780 * Note that the queue implementation here is a little funky; neither the PI or
1781 * CI will ever be zero. This behaviour is a controller feature.
1782 */
1783static struct {
1784 int size;
1785 int notify;
1786} aac_qinfo[] = {
1787 {AAC_HOST_NORM_CMD_ENTRIES, AAC_DB_COMMAND_NOT_FULL},
1788 {AAC_HOST_HIGH_CMD_ENTRIES, 0},
1789 {AAC_ADAP_NORM_CMD_ENTRIES, AAC_DB_COMMAND_READY},
1790 {AAC_ADAP_HIGH_CMD_ENTRIES, 0},
1791 {AAC_HOST_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_NOT_FULL},
1792 {AAC_HOST_HIGH_RESP_ENTRIES, 0},
1793 {AAC_ADAP_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_READY},
1794 {AAC_ADAP_HIGH_RESP_ENTRIES, 0}
1795};
1796
1797/*
1798 * Atomically insert an entry into the nominated queue, returns 0 on success or
1799 * EBUSY if the queue is full.
1800 *
1801 * Note: it would be more efficient to defer notifying the controller in
1802 * the case where we may be inserting several entries in rapid succession,
1803 * but implementing this usefully may be difficult (it would involve a
1804 * separate queue/notify interface).
1805 */
1806static int
1807aac_enqueue_fib(struct aac_softc *sc, int queue, struct aac_command *cm)
1808{
1809 u_int32_t pi, ci;
1810 int error;
1811 u_int32_t fib_size;
1812 u_int32_t fib_addr;
1813
1814 debug_called(3);
1815
1816 fib_size = cm->cm_fib->Header.Size;
1817 fib_addr = cm->cm_fib->Header.ReceiverFibAddress;
1818
1819 /* get the producer/consumer indices */
1820 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
1821 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
1822
1823 /* wrap the queue? */
1824 if (pi >= aac_qinfo[queue].size)
1825 pi = 0;
1826
1827 /* check for queue full */
1828 if ((pi + 1) == ci) {
1829 error = EBUSY;
1830 goto out;
1831 }
1832
1833 /* populate queue entry */
1834 (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size;
1835 (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr;
1836
1837 /* update producer index */
1838 sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;
1839
1840 /*
1841 * To avoid a race with its completion interrupt, place this command on
1842 * the busy queue prior to advertising it to the controller.
1843 */
1844 aac_enqueue_busy(cm);
1845
1846 /* notify the adapter if we know how */
1847 if (aac_qinfo[queue].notify != 0)
1848 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
1849
1850 error = 0;
1851
1852out:
1853 return(error);
1854}
1855
1856/*
1857 * Atomically remove one entry from the nominated queue, returns 0 on
1858 * success or ENOENT if the queue is empty.
1859 */
1860static int
1861aac_dequeue_fib(struct aac_softc *sc, int queue, u_int32_t *fib_size,
1862 struct aac_fib **fib_addr)
1863{
1864 u_int32_t pi, ci;
1865 u_int32_t fib_index;
1866 int error;
1867 int notify;
1868
1869 debug_called(3);
1870
1871 /* get the producer/consumer indices */
1872 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
1873 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
1874
1875 /* check for queue empty */
1876 if (ci == pi) {
1877 error = ENOENT;
1878 goto out;
1879 }
1880
1881 /* wrap the pi so the following test works */
1882 if (pi >= aac_qinfo[queue].size)
1883 pi = 0;
1884
1885 notify = 0;
1886 if (ci == pi + 1)
1887 notify++;
1888
1889 /* wrap the queue? */
1890 if (ci >= aac_qinfo[queue].size)
1891 ci = 0;
1892
1893 /* fetch the entry */
1894 *fib_size = (sc->aac_qentries[queue] + ci)->aq_fib_size;
1895
1896 switch (queue) {
1897 case AAC_HOST_NORM_CMD_QUEUE:
1898 case AAC_HOST_HIGH_CMD_QUEUE:
1899 /*
1900 * The aq_fib_addr is only 32 bits wide so it can't be counted
1901 * on to hold an address. For AIF's, the adapter assumes
1902 * that it's giving us an address into the array of AIF fibs.
1903 * Therefore, we have to convert it to an index.
1904 */
1905 fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr /
1906 sizeof(struct aac_fib);
1907 *fib_addr = &sc->aac_common->ac_fibs[fib_index];
1908 break;
1909
1910 case AAC_HOST_NORM_RESP_QUEUE:
1911 case AAC_HOST_HIGH_RESP_QUEUE:
1912 {
1913 struct aac_command *cm;
1914
1915 /*
1916 * As above, an index is used instead of an actual address.
1917 * Gotta shift the index to account for the fast response
1918 * bit. No other correction is needed since this value was
1919 * originally provided by the driver via the SenderFibAddress
1920 * field.
1921 */
1922 fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr;
1923 cm = sc->aac_commands + (fib_index >> 1);
1924 *fib_addr = cm->cm_fib;
1925
1926 /*
1927 * Is this a fast response? If it is, update the fib fields in
1928 * local memory since the whole fib isn't DMA'd back up.
1929 */
1930 if (fib_index & 0x01) {
1931 (*fib_addr)->Header.XferState |= AAC_FIBSTATE_DONEADAP;
1932 *((u_int32_t*)((*fib_addr)->data)) = AAC_ERROR_NORMAL;
1933 }
1934 break;
1935 }
1936 default:
1937 panic("Invalid queue in aac_dequeue_fib()");
1938 break;
1939 }
1940
1941 /* update consumer index */
1942 sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX] = ci + 1;
1943
1944 /* if we have made the queue un-full, notify the adapter */
1945 if (notify && (aac_qinfo[queue].notify != 0))
1946 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
1947 error = 0;
1948
1949out:
1950 return(error);
1951}
1952
1953/*
1954 * Put our response to an Adapter Initialed Fib on the response queue
1955 */
1956static int
1957aac_enqueue_response(struct aac_softc *sc, int queue, struct aac_fib *fib)
1958{
1959 u_int32_t pi, ci;
1960 int error;
1961 u_int32_t fib_size;
1962 u_int32_t fib_addr;
1963
1964 debug_called(1);
1965
1966 /* Tell the adapter where the FIB is */
1967 fib_size = fib->Header.Size;
1968 fib_addr = fib->Header.SenderFibAddress;
1969 fib->Header.ReceiverFibAddress = fib_addr;
1970
1971 /* get the producer/consumer indices */
1972 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
1973 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
1974
1975 /* wrap the queue? */
1976 if (pi >= aac_qinfo[queue].size)
1977 pi = 0;
1978
1979 /* check for queue full */
1980 if ((pi + 1) == ci) {
1981 error = EBUSY;
1982 goto out;
1983 }
1984
1985 /* populate queue entry */
1986 (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size;
1987 (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr;
1988
1989 /* update producer index */
1990 sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;
1991
1992 /* notify the adapter if we know how */
1993 if (aac_qinfo[queue].notify != 0)
1994 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
1995
1996 error = 0;
1997
1998out:
1999 return(error);
2000}
2001
2002/*
2003 * Check for commands that have been outstanding for a suspiciously long time,
2004 * and complain about them.
2005 */
2006static void
2007aac_timeout(struct aac_softc *sc)
2008{
2009 struct aac_command *cm;
2010 time_t deadline;
2011
2012 /*
2013 * Traverse the busy command list, bitch about late commands once
2014 * only.
2015 */
2016 deadline = time_second - AAC_CMD_TIMEOUT;
2017 TAILQ_FOREACH(cm, &sc->aac_busy, cm_link) {
2018 if ((cm->cm_timestamp < deadline)
2019 /* && !(cm->cm_flags & AAC_CMD_TIMEDOUT) */) {
2020 cm->cm_flags |= AAC_CMD_TIMEDOUT;
2021 device_printf(sc->aac_dev,
2022 "COMMAND %p TIMEOUT AFTER %d SECONDS\n",
2023 cm, (int)(time_second-cm->cm_timestamp));
2024 AAC_PRINT_FIB(sc, cm->cm_fib);
2025 }
2026 }
2027
2028 return;
2029}
2030
2031/*
2032 * Interface Function Vectors
2033 */
2034
2035/*
2036 * Read the current firmware status word.
2037 */
2038static int
2039aac_sa_get_fwstatus(struct aac_softc *sc)
2040{
2041 debug_called(3);
2042
2043 return(AAC_GETREG4(sc, AAC_SA_FWSTATUS));
2044}
2045
2046static int
2047aac_rx_get_fwstatus(struct aac_softc *sc)
2048{
2049 debug_called(3);
2050
2051 return(AAC_GETREG4(sc, AAC_RX_FWSTATUS));
2052}
2053
2054static int
2055aac_fa_get_fwstatus(struct aac_softc *sc)
2056{
2057 int val;
2058
2059 debug_called(3);
2060
2061 val = AAC_GETREG4(sc, AAC_FA_FWSTATUS);
2062 return (val);
2063}
2064
2065/*
2066 * Notify the controller of a change in a given queue
2067 */
2068
2069static void
2070aac_sa_qnotify(struct aac_softc *sc, int qbit)
2071{
2072 debug_called(3);
2073
2074 AAC_SETREG2(sc, AAC_SA_DOORBELL1_SET, qbit);
2075}
2076
2077static void
2078aac_rx_qnotify(struct aac_softc *sc, int qbit)
2079{
2080 debug_called(3);
2081
2082 AAC_SETREG4(sc, AAC_RX_IDBR, qbit);
2083}
2084
2085static void
2086aac_fa_qnotify(struct aac_softc *sc, int qbit)
2087{
2088 debug_called(3);
2089
2090 AAC_SETREG2(sc, AAC_FA_DOORBELL1, qbit);
2091 AAC_FA_HACK(sc);
2092}
2093
2094/*
2095 * Get the interrupt reason bits
2096 */
2097static int
2098aac_sa_get_istatus(struct aac_softc *sc)
2099{
2100 debug_called(3);
2101
2102 return(AAC_GETREG2(sc, AAC_SA_DOORBELL0));
2103}
2104
2105static int
2106aac_rx_get_istatus(struct aac_softc *sc)
2107{
2108 debug_called(3);
2109
2110 return(AAC_GETREG4(sc, AAC_RX_ODBR));
2111}
2112
2113static int
2114aac_fa_get_istatus(struct aac_softc *sc)
2115{
2116 int val;
2117
2118 debug_called(3);
2119
2120 val = AAC_GETREG2(sc, AAC_FA_DOORBELL0);
2121 return (val);
2122}
2123
2124/*
2125 * Clear some interrupt reason bits
2126 */
2127static void
2128aac_sa_clear_istatus(struct aac_softc *sc, int mask)
2129{
2130 debug_called(3);
2131
2132 AAC_SETREG2(sc, AAC_SA_DOORBELL0_CLEAR, mask);
2133}
2134
2135static void
2136aac_rx_clear_istatus(struct aac_softc *sc, int mask)
2137{
2138 debug_called(3);
2139
2140 AAC_SETREG4(sc, AAC_RX_ODBR, mask);
2141}
2142
2143static void
2144aac_fa_clear_istatus(struct aac_softc *sc, int mask)
2145{
2146 debug_called(3);
2147
2148 AAC_SETREG2(sc, AAC_FA_DOORBELL0_CLEAR, mask);
2149 AAC_FA_HACK(sc);
2150}
2151
2152/*
2153 * Populate the mailbox and set the command word
2154 */
2155static void
2156aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command,
2157 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2158{
2159 debug_called(4);
2160
2161 AAC_SETREG4(sc, AAC_SA_MAILBOX, command);
2162 AAC_SETREG4(sc, AAC_SA_MAILBOX + 4, arg0);
2163 AAC_SETREG4(sc, AAC_SA_MAILBOX + 8, arg1);
2164 AAC_SETREG4(sc, AAC_SA_MAILBOX + 12, arg2);
2165 AAC_SETREG4(sc, AAC_SA_MAILBOX + 16, arg3);
2166}
2167
2168static void
2169aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command,
2170 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2171{
2172 debug_called(4);
2173
2174 AAC_SETREG4(sc, AAC_RX_MAILBOX, command);
2175 AAC_SETREG4(sc, AAC_RX_MAILBOX + 4, arg0);
2176 AAC_SETREG4(sc, AAC_RX_MAILBOX + 8, arg1);
2177 AAC_SETREG4(sc, AAC_RX_MAILBOX + 12, arg2);
2178 AAC_SETREG4(sc, AAC_RX_MAILBOX + 16, arg3);
2179}
2180
2181static void
2182aac_fa_set_mailbox(struct aac_softc *sc, u_int32_t command,
2183 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2184{
2185 debug_called(4);
2186
2187 AAC_SETREG4(sc, AAC_FA_MAILBOX, command);
2188 AAC_FA_HACK(sc);
2189 AAC_SETREG4(sc, AAC_FA_MAILBOX + 4, arg0);
2190 AAC_FA_HACK(sc);
2191 AAC_SETREG4(sc, AAC_FA_MAILBOX + 8, arg1);
2192 AAC_FA_HACK(sc);
2193 AAC_SETREG4(sc, AAC_FA_MAILBOX + 12, arg2);
2194 AAC_FA_HACK(sc);
2195 AAC_SETREG4(sc, AAC_FA_MAILBOX + 16, arg3);
2196 AAC_FA_HACK(sc);
2197}
2198
2199/*
2200 * Fetch the immediate command status word
2201 */
2202static int
2203aac_sa_get_mailbox(struct aac_softc *sc, int mb)
2204{
2205 debug_called(4);
2206
2207 return(AAC_GETREG4(sc, AAC_SA_MAILBOX + (mb * 4)));
2208}
2209
2210static int
2211aac_rx_get_mailbox(struct aac_softc *sc, int mb)
2212{
2213 debug_called(4);
2214
2215 return(AAC_GETREG4(sc, AAC_RX_MAILBOX + (mb * 4)));
2216}
2217
2218static int
2219aac_fa_get_mailbox(struct aac_softc *sc, int mb)
2220{
2221 int val;
2222
2223 debug_called(4);
2224
2225 val = AAC_GETREG4(sc, AAC_FA_MAILBOX + (mb * 4));
2226 return (val);
2227}
2228
2229/*
2230 * Set/clear interrupt masks
2231 */
2232static void
2233aac_sa_set_interrupts(struct aac_softc *sc, int enable)
2234{
2235 debug(2, "%sable interrupts", enable ? "en" : "dis");
2236
2237 if (enable) {
2238 AAC_SETREG2((sc), AAC_SA_MASK0_CLEAR, AAC_DB_INTERRUPTS);
2239 } else {
2240 AAC_SETREG2((sc), AAC_SA_MASK0_SET, ~0);
2241 }
2242}
2243
2244static void
2245aac_rx_set_interrupts(struct aac_softc *sc, int enable)
2246{
2247 debug(2, "%sable interrupts", enable ? "en" : "dis");
2248
2249 if (enable) {
2250 AAC_SETREG4(sc, AAC_RX_OIMR, ~AAC_DB_INTERRUPTS);
2251 } else {
2252 AAC_SETREG4(sc, AAC_RX_OIMR, ~0);
2253 }
2254}
2255
2256static void
2257aac_fa_set_interrupts(struct aac_softc *sc, int enable)
2258{
2259 debug(2, "%sable interrupts", enable ? "en" : "dis");
2260
2261 if (enable) {
2262 AAC_SETREG2((sc), AAC_FA_MASK0_CLEAR, AAC_DB_INTERRUPTS);
2263 AAC_FA_HACK(sc);
2264 } else {
2265 AAC_SETREG2((sc), AAC_FA_MASK0, ~0);
2266 AAC_FA_HACK(sc);
2267 }
2268}
2269
2270/*
2271 * Debugging and Diagnostics
2272 */
2273
2274/*
2275 * Print some information about the controller.
2276 */
2277static void
2278aac_describe_controller(struct aac_softc *sc)
2279{
2280 struct aac_fib *fib;
2281 struct aac_adapter_info *info;
2282
2283 debug_called(2);
2284
2285 aac_alloc_sync_fib(sc, &fib, 0);
2286
2287 fib->data[0] = 0;
2288 if (aac_sync_fib(sc, RequestAdapterInfo, 0, fib, 1)) {
2289 device_printf(sc->aac_dev, "RequestAdapterInfo failed\n");
2290 aac_release_sync_fib(sc);
2291 return;
2292 }
2293 info = (struct aac_adapter_info *)&fib->data[0];
2294
2295 device_printf(sc->aac_dev, "%s %dMHz, %dMB cache memory, %s\n",
2296 aac_describe_code(aac_cpu_variant, info->CpuVariant),
2297 info->ClockSpeed, info->BufferMem / (1024 * 1024),
2298 aac_describe_code(aac_battery_platform,
2299 info->batteryPlatform));
2300
2301 /* save the kernel revision structure for later use */
2302 sc->aac_revision = info->KernelRevision;
2303 device_printf(sc->aac_dev, "Kernel %d.%d-%d, Build %d, S/N %6X\n",
2304 info->KernelRevision.external.comp.major,
2305 info->KernelRevision.external.comp.minor,
2306 info->KernelRevision.external.comp.dash,
2307 info->KernelRevision.buildNumber,
2308 (u_int32_t)(info->SerialNumber & 0xffffff));
2309
2310 aac_release_sync_fib(sc);
2311
2312 if (1 || bootverbose) {
2313 device_printf(sc->aac_dev, "Supported Options=%b\n",
2314 sc->supported_options,
2315 "\20"
2316 "\1SNAPSHOT"
2317 "\2CLUSTERS"
2318 "\3WCACHE"
2319 "\4DATA64"
2320 "\5HOSTTIME"
2321 "\6RAID50"
2322 "\7WINDOW4GB"
2323 "\10SCSIUPGD"
2324 "\11SOFTERR"
2325 "\12NORECOND"
2326 "\13SGMAP64"
2327 "\14ALARM"
2328 "\15NONDASD");
2329 }
2330}
2331
2332/*
2333 * Look up a text description of a numeric error code and return a pointer to
2334 * same.
2335 */
2336static char *
2337aac_describe_code(struct aac_code_lookup *table, u_int32_t code)
2338{
2339 int i;
2340
2341 for (i = 0; table[i].string != NULL; i++)
2342 if (table[i].code == code)
2343 return(table[i].string);
2344 return(table[i + 1].string);
2345}
2346
2347/*
2348 * Management Interface
2349 */
2350
2351static int
2352aac_open(dev_t dev, int flags, int fmt, d_thread_t *td)
2353{
2354 struct aac_softc *sc;
2355
2356 debug_called(2);
2357
2358 sc = dev->si_drv1;
2359
2360 /* Check to make sure the device isn't already open */
2361 if (sc->aac_state & AAC_STATE_OPEN) {
2362 return EBUSY;
2363 }
2364 sc->aac_state |= AAC_STATE_OPEN;
2365
2366 return 0;
2367}
2368
2369static int
2370aac_close(dev_t dev, int flags, int fmt, d_thread_t *td)
2371{
2372 struct aac_softc *sc;
2373
2374 debug_called(2);
2375
2376 sc = dev->si_drv1;
2377
2378 /* Mark this unit as no longer open */
2379 sc->aac_state &= ~AAC_STATE_OPEN;
2380
2381 return 0;
2382}
2383
2384static int
2385aac_ioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, d_thread_t *td)
2386{
2387 union aac_statrequest *as;
2388 struct aac_softc *sc;
2389 int error = 0;
2390 uint32_t cookie;
2391
2392 debug_called(2);
2393
2394 as = (union aac_statrequest *)arg;
2395 sc = dev->si_drv1;
2396
2397 switch (cmd) {
2398 case AACIO_STATS:
2399 switch (as->as_item) {
2400 case AACQ_FREE:
2401 case AACQ_BIO:
2402 case AACQ_READY:
2403 case AACQ_BUSY:
2404 bcopy(&sc->aac_qstat[as->as_item], &as->as_qstat,
2405 sizeof(struct aac_qstat));
2406 break;
2407 default:
2408 error = ENOENT;
2409 break;
2410 }
2411 break;
2412
2413 case FSACTL_SENDFIB:
2414 arg = *(caddr_t*)arg;
2415 case FSACTL_LNX_SENDFIB:
2416 debug(1, "FSACTL_SENDFIB");
2417 error = aac_ioctl_sendfib(sc, arg);
2418 break;
2419 case FSACTL_AIF_THREAD:
2420 case FSACTL_LNX_AIF_THREAD:
2421 debug(1, "FSACTL_AIF_THREAD");
2422 error = EINVAL;
2423 break;
2424 case FSACTL_OPEN_GET_ADAPTER_FIB:
2425 arg = *(caddr_t*)arg;
2426 case FSACTL_LNX_OPEN_GET_ADAPTER_FIB:
2427 debug(1, "FSACTL_OPEN_GET_ADAPTER_FIB");
2428 /*
2429 * Pass the caller out an AdapterFibContext.
2430 *
2431 * Note that because we only support one opener, we
2432 * basically ignore this. Set the caller's context to a magic
2433 * number just in case.
2434 *
2435 * The Linux code hands the driver a pointer into kernel space,
2436 * and then trusts it when the caller hands it back. Aiee!
2437 * Here, we give it the proc pointer of the per-adapter aif
2438 * thread. It's only used as a sanity check in other calls.
2439 */
2440 cookie = (uint32_t)(uintptr_t)sc->aifthread;
2441 error = copyout(&cookie, arg, sizeof(cookie));
2442 break;
2443 case FSACTL_GET_NEXT_ADAPTER_FIB:
2444 arg = *(caddr_t*)arg;
2445 case FSACTL_LNX_GET_NEXT_ADAPTER_FIB:
2446 debug(1, "FSACTL_GET_NEXT_ADAPTER_FIB");
2447 error = aac_getnext_aif(sc, arg);
2448 break;
2449 case FSACTL_CLOSE_GET_ADAPTER_FIB:
2450 case FSACTL_LNX_CLOSE_GET_ADAPTER_FIB:
2451 debug(1, "FSACTL_CLOSE_GET_ADAPTER_FIB");
2452 /* don't do anything here */
2453 break;
2454 case FSACTL_MINIPORT_REV_CHECK:
2455 arg = *(caddr_t*)arg;
2456 case FSACTL_LNX_MINIPORT_REV_CHECK:
2457 debug(1, "FSACTL_MINIPORT_REV_CHECK");
2458 error = aac_rev_check(sc, arg);
2459 break;
2460 case FSACTL_QUERY_DISK:
2461 arg = *(caddr_t*)arg;
2462 case FSACTL_LNX_QUERY_DISK:
2463 debug(1, "FSACTL_QUERY_DISK");
2464 error = aac_query_disk(sc, arg);
2465 break;
2466 case FSACTL_DELETE_DISK:
2467 case FSACTL_LNX_DELETE_DISK:
2468 /*
2469 * We don't trust the underland to tell us when to delete a
2470 * container, rather we rely on an AIF coming from the
2471 * controller
2472 */
2473 error = 0;
2474 break;
2475 default:
2476 debug(1, "unsupported cmd 0x%lx\n", cmd);
2477 error = EINVAL;
2478 break;
2479 }
2480 return(error);
2481}
2482
2483static int
2484aac_poll(dev_t dev, int poll_events, d_thread_t *td)
2485{
2486 struct aac_softc *sc;
2487 int revents;
2488
2489 sc = dev->si_drv1;
2490 revents = 0;
2491
2492 AAC_LOCK_ACQUIRE(&sc->aac_aifq_lock);
2493 if ((poll_events & (POLLRDNORM | POLLIN)) != 0) {
2494 if (sc->aac_aifq_tail != sc->aac_aifq_head)
2495 revents |= poll_events & (POLLIN | POLLRDNORM);
2496 }
2497 AAC_LOCK_RELEASE(&sc->aac_aifq_lock);
2498
2499 if (revents == 0) {
2500 if (poll_events & (POLLIN | POLLRDNORM))
2501 selrecord(td, &sc->rcv_select);
2502 }
2503
2504 return (revents);
2505}
2506
2507/*
2508 * Send a FIB supplied from userspace
2509 */
2510static int
2511aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib)
2512{
2513 struct aac_command *cm;
2514 int size, error;
2515
2516 debug_called(2);
2517
2518 cm = NULL;
2519
2520 /*
2521 * Get a command
2522 */
2523 AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
2524 if (aac_alloc_command(sc, &cm)) {
2525 error = EBUSY;
2526 goto out;
2527 }
2528
2529 /*
2530 * Fetch the FIB header, then re-copy to get data as well.
2531 */
2532 if ((error = copyin(ufib, cm->cm_fib,
2533 sizeof(struct aac_fib_header))) != 0)
2534 goto out;
2535 size = cm->cm_fib->Header.Size + sizeof(struct aac_fib_header);
2536 if (size > sizeof(struct aac_fib)) {
2537 device_printf(sc->aac_dev, "incoming FIB oversized (%d > %zd)\n",
2538 size, sizeof(struct aac_fib));
2539 size = sizeof(struct aac_fib);
2540 }
2541 if ((error = copyin(ufib, cm->cm_fib, size)) != 0)
2542 goto out;
2543 cm->cm_fib->Header.Size = size;
2544 cm->cm_timestamp = time_second;
2545
2546 /*
2547 * Pass the FIB to the controller, wait for it to complete.
2548 */
2549 if ((error = aac_wait_command(cm, 30)) != 0) { /* XXX user timeout? */
2550 device_printf(sc->aac_dev,
2551 "aac_wait_command return %d\n", error);
2552 goto out;
2553 }
2554
2555 /*
2556 * Copy the FIB and data back out to the caller.
2557 */
2558 size = cm->cm_fib->Header.Size;
2559 if (size > sizeof(struct aac_fib)) {
2560 device_printf(sc->aac_dev, "outbound FIB oversized (%d > %zd)\n",
2561 size, sizeof(struct aac_fib));
2562 size = sizeof(struct aac_fib);
2563 }
2564 error = copyout(cm->cm_fib, ufib, size);
2565
2566out:
2567 if (cm != NULL) {
2568 aac_release_command(cm);
2569 }
2570
2571 AAC_LOCK_RELEASE(&sc->aac_io_lock);
2572 return(error);
2573}
2574
2575/*
2576 * Handle an AIF sent to us by the controller; queue it for later reference.
2577 * If the queue fills up, then drop the older entries.
2578 */
2579static void
2580aac_handle_aif(struct aac_softc *sc, struct aac_fib *fib)
2581{
2582 struct aac_aif_command *aif;
2583 struct aac_container *co, *co_next;
2584 struct aac_mntinfo *mi;
2585 struct aac_mntinforesp *mir = NULL;
2586 u_int16_t rsize;
2587 int next, found;
2588 int count = 0, added = 0, i = 0;
2589
2590 debug_called(2);
2591
2592 aif = (struct aac_aif_command*)&fib->data[0];
2593 aac_print_aif(sc, aif);
2594
2595 /* Is it an event that we should care about? */
2596 switch (aif->command) {
2597 case AifCmdEventNotify:
2598 switch (aif->data.EN.type) {
2599 case AifEnAddContainer:
2600 case AifEnDeleteContainer:
2601 /*
2602 * A container was added or deleted, but the message
2603 * doesn't tell us anything else! Re-enumerate the
2604 * containers and sort things out.
2605 */
2606 aac_alloc_sync_fib(sc, &fib, 0);
2607 mi = (struct aac_mntinfo *)&fib->data[0];
2608 do {
2609 /*
2610 * Ask the controller for its containers one at
2611 * a time.
2612 * XXX What if the controller's list changes
2613 * midway through this enumaration?
2614 * XXX This should be done async.
2615 */
2616 bzero(mi, sizeof(struct aac_mntinfo));
2617 mi->Command = VM_NameServe;
2618 mi->MntType = FT_FILESYS;
2619 mi->MntCount = i;
2620 rsize = sizeof(mir);
2621 if (aac_sync_fib(sc, ContainerCommand, 0, fib,
2622 sizeof(struct aac_mntinfo))) {
2623 printf("Error probing container %d\n",
2624 i);
2625 continue;
2626 }
2627 mir = (struct aac_mntinforesp *)&fib->data[0];
2628 /* XXX Need to check if count changed */
2629 count = mir->MntRespCount;
2630 /*
2631 * Check the container against our list.
2632 * co->co_found was already set to 0 in a
2633 * previous run.
2634 */
2635 if ((mir->Status == ST_OK) &&
2636 (mir->MntTable[0].VolType != CT_NONE)) {
2637 found = 0;
2638 TAILQ_FOREACH(co,
2639 &sc->aac_container_tqh,
2640 co_link) {
2641 if (co->co_mntobj.ObjectId ==
2642 mir->MntTable[0].ObjectId) {
2643 co->co_found = 1;
2644 found = 1;
2645 break;
2646 }
2647 }
2648 /*
2649 * If the container matched, continue
2650 * in the list.
2651 */
2652 if (found) {
2653 i++;
2654 continue;
2655 }
2656
2657 /*
2658 * This is a new container. Do all the
2659 * appropriate things to set it up.
2660 */
2661 aac_add_container(sc, mir, 1);
2662 added = 1;
2663 }
2664 i++;
2665 } while ((i < count) && (i < AAC_MAX_CONTAINERS));
2666 aac_release_sync_fib(sc);
2667
2668 /*
2669 * Go through our list of containers and see which ones
2670 * were not marked 'found'. Since the controller didn't
2671 * list them they must have been deleted. Do the
2672 * appropriate steps to destroy the device. Also reset
2673 * the co->co_found field.
2674 */
2675 co = TAILQ_FIRST(&sc->aac_container_tqh);
2676 while (co != NULL) {
2677 if (co->co_found == 0) {
2678 device_delete_child(sc->aac_dev,
2679 co->co_disk);
2680 co_next = TAILQ_NEXT(co, co_link);
2681 AAC_LOCK_ACQUIRE(&sc->
2682 aac_container_lock);
2683 TAILQ_REMOVE(&sc->aac_container_tqh, co,
2684 co_link);
2685 AAC_LOCK_RELEASE(&sc->
2686 aac_container_lock);
2687 FREE(co, M_AACBUF);
2688 co = co_next;
2689 } else {
2690 co->co_found = 0;
2691 co = TAILQ_NEXT(co, co_link);
2692 }
2693 }
2694
2695 /* Attach the newly created containers */
2696 if (added)
2697 bus_generic_attach(sc->aac_dev);
2698
2699 break;
2700
2701 default:
2702 break;
2703 }
2704
2705 default:
2706 break;
2707 }
2708
2709 /* Copy the AIF data to the AIF queue for ioctl retrieval */
2710 AAC_LOCK_ACQUIRE(&sc->aac_aifq_lock);
2711 next = (sc->aac_aifq_head + 1) % AAC_AIFQ_LENGTH;
2712 if (next != sc->aac_aifq_tail) {
2713 bcopy(aif, &sc->aac_aifq[next], sizeof(struct aac_aif_command));
2714 sc->aac_aifq_head = next;
2715
2716 /* On the off chance that someone is sleeping for an aif... */
2717 if (sc->aac_state & AAC_STATE_AIF_SLEEPER)
2718 wakeup(sc->aac_aifq);
2719 /* Wakeup any poll()ers */
2720 selwakeuppri(&sc->rcv_select, PRIBIO);
2721 }
2722 AAC_LOCK_RELEASE(&sc->aac_aifq_lock);
2723
2724 return;
2725}
2726
2727/*
2728 * Return the Revision of the driver to userspace and check to see if the
2729 * userspace app is possibly compatible. This is extremely bogus since
2730 * our driver doesn't follow Adaptec's versioning system. Cheat by just
2731 * returning what the card reported.
2732 */
2733static int
2734aac_rev_check(struct aac_softc *sc, caddr_t udata)
2735{
2736 struct aac_rev_check rev_check;
2737 struct aac_rev_check_resp rev_check_resp;
2738 int error = 0;
2739
2740 debug_called(2);
2741
2742 /*
2743 * Copyin the revision struct from userspace
2744 */
2745 if ((error = copyin(udata, (caddr_t)&rev_check,
2746 sizeof(struct aac_rev_check))) != 0) {
2747 return error;
2748 }
2749
2750 debug(2, "Userland revision= %d\n",
2751 rev_check.callingRevision.buildNumber);
2752
2753 /*
2754 * Doctor up the response struct.
2755 */
2756 rev_check_resp.possiblyCompatible = 1;
2757 rev_check_resp.adapterSWRevision.external.ul =
2758 sc->aac_revision.external.ul;
2759 rev_check_resp.adapterSWRevision.buildNumber =
2760 sc->aac_revision.buildNumber;
2761
2762 return(copyout((caddr_t)&rev_check_resp, udata,
2763 sizeof(struct aac_rev_check_resp)));
2764}
2765
2766/*
2767 * Pass the caller the next AIF in their queue
2768 */
2769static int
2770aac_getnext_aif(struct aac_softc *sc, caddr_t arg)
2771{
2772 struct get_adapter_fib_ioctl agf;
2773 int error;
2774
2775 debug_called(2);
2776
2777 if ((error = copyin(arg, &agf, sizeof(agf))) == 0) {
2778
2779 /*
2780 * Check the magic number that we gave the caller.
2781 */
2782 if (agf.AdapterFibContext != (int)(uintptr_t)sc->aifthread) {
2783 error = EFAULT;
2784 } else {
2785 error = aac_return_aif(sc, agf.AifFib);
2786 if ((error == EAGAIN) && (agf.Wait)) {
2787 sc->aac_state |= AAC_STATE_AIF_SLEEPER;
2788 while (error == EAGAIN) {
2789 error = tsleep(sc->aac_aifq, PRIBIO |
2790 PCATCH, "aacaif", 0);
2791 if (error == 0)
2792 error = aac_return_aif(sc,
2793 agf.AifFib);
2794 }
2795 sc->aac_state &= ~AAC_STATE_AIF_SLEEPER;
2796 }
2797 }
2798 }
2799 return(error);
2800}
2801
2802/*
2803 * Hand the next AIF off the top of the queue out to userspace.
2804 */
2805static int
2806aac_return_aif(struct aac_softc *sc, caddr_t uptr)
2807{
2808 int next, error;
2809
2810 debug_called(2);
2811
2812 AAC_LOCK_ACQUIRE(&sc->aac_aifq_lock);
2813 if (sc->aac_aifq_tail == sc->aac_aifq_head) {
2814 AAC_LOCK_RELEASE(&sc->aac_aifq_lock);
2815 return (EAGAIN);
2816 }
2817
2818 next = (sc->aac_aifq_tail + 1) % AAC_AIFQ_LENGTH;
2819 error = copyout(&sc->aac_aifq[next], uptr,
2820 sizeof(struct aac_aif_command));
2821 if (error)
2822 device_printf(sc->aac_dev,
2823 "aac_return_aif: copyout returned %d\n", error);
2824 else
2825 sc->aac_aifq_tail = next;
2826
2827 AAC_LOCK_RELEASE(&sc->aac_aifq_lock);
2828 return(error);
2829}
2830
2831/*
2832 * Give the userland some information about the container. The AAC arch
2833 * expects the driver to be a SCSI passthrough type driver, so it expects
2834 * the containers to have b:t:l numbers. Fake it.
2835 */
2836static int
2837aac_query_disk(struct aac_softc *sc, caddr_t uptr)
2838{
2839 struct aac_query_disk query_disk;
2840 struct aac_container *co;
2841 struct aac_disk *disk;
2842 int error, id;
2843
2844 debug_called(2);
2845
2846 disk = NULL;
2847
2848 error = copyin(uptr, (caddr_t)&query_disk,
2849 sizeof(struct aac_query_disk));
2850 if (error)
2851 return (error);
2852
2853 id = query_disk.ContainerNumber;
2854 if (id == -1)
2855 return (EINVAL);
2856
2857 AAC_LOCK_ACQUIRE(&sc->aac_container_lock);
2858 TAILQ_FOREACH(co, &sc->aac_container_tqh, co_link) {
2859 if (co->co_mntobj.ObjectId == id)
2860 break;
2861 }
2862
2863 if (co == NULL) {
2864 query_disk.Valid = 0;
2865 query_disk.Locked = 0;
2866 query_disk.Deleted = 1; /* XXX is this right? */
2867 } else {
2868 disk = device_get_softc(co->co_disk);
2869 query_disk.Valid = 1;
2870 query_disk.Locked =
2871 (disk->ad_flags & AAC_DISK_OPEN) ? 1 : 0;
2872 query_disk.Deleted = 0;
2873 query_disk.Bus = device_get_unit(sc->aac_dev);
2874 query_disk.Target = disk->unit;
2875 query_disk.Lun = 0;
2876 query_disk.UnMapped = 0;
2877 sprintf(&query_disk.diskDeviceName[0], "%s%d",
| 32
33/*
34 * Driver for the Adaptec 'FSA' family of PCI/SCSI RAID adapters.
35 */
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/sysctl.h>
46#include <sys/poll.h>
47#include <sys/ioccom.h>
48
49#include <sys/bus.h>
50#include <sys/conf.h>
51#include <sys/signalvar.h>
52#include <sys/time.h>
53#include <sys/eventhandler.h>
54
55#include <machine/bus_memio.h>
56#include <machine/bus.h>
57#include <machine/resource.h>
58
59#include <dev/aac/aacreg.h>
60#include <dev/aac/aac_ioctl.h>
61#include <dev/aac/aacvar.h>
62#include <dev/aac/aac_tables.h>
63
64static void aac_startup(void *arg);
65static void aac_add_container(struct aac_softc *sc,
66 struct aac_mntinforesp *mir, int f);
67static void aac_get_bus_info(struct aac_softc *sc);
68
69/* Command Processing */
70static void aac_timeout(struct aac_softc *sc);
71static int aac_map_command(struct aac_command *cm);
72static void aac_complete(void *context, int pending);
73static int aac_bio_command(struct aac_softc *sc, struct aac_command **cmp);
74static void aac_bio_complete(struct aac_command *cm);
75static int aac_wait_command(struct aac_command *cm, int timeout);
76static void aac_command_thread(struct aac_softc *sc);
77
78/* Command Buffer Management */
79static void aac_map_command_sg(void *arg, bus_dma_segment_t *segs,
80 int nseg, int error);
81static void aac_map_command_helper(void *arg, bus_dma_segment_t *segs,
82 int nseg, int error);
83static int aac_alloc_commands(struct aac_softc *sc);
84static void aac_free_commands(struct aac_softc *sc);
85static void aac_unmap_command(struct aac_command *cm);
86
87/* Hardware Interface */
88static void aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg,
89 int error);
90static int aac_check_firmware(struct aac_softc *sc);
91static int aac_init(struct aac_softc *sc);
92static int aac_sync_command(struct aac_softc *sc, u_int32_t command,
93 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2,
94 u_int32_t arg3, u_int32_t *sp);
95static int aac_enqueue_fib(struct aac_softc *sc, int queue,
96 struct aac_command *cm);
97static int aac_dequeue_fib(struct aac_softc *sc, int queue,
98 u_int32_t *fib_size, struct aac_fib **fib_addr);
99static int aac_enqueue_response(struct aac_softc *sc, int queue,
100 struct aac_fib *fib);
101
102/* Falcon/PPC interface */
103static int aac_fa_get_fwstatus(struct aac_softc *sc);
104static void aac_fa_qnotify(struct aac_softc *sc, int qbit);
105static int aac_fa_get_istatus(struct aac_softc *sc);
106static void aac_fa_clear_istatus(struct aac_softc *sc, int mask);
107static void aac_fa_set_mailbox(struct aac_softc *sc, u_int32_t command,
108 u_int32_t arg0, u_int32_t arg1,
109 u_int32_t arg2, u_int32_t arg3);
110static int aac_fa_get_mailbox(struct aac_softc *sc, int mb);
111static void aac_fa_set_interrupts(struct aac_softc *sc, int enable);
112
113struct aac_interface aac_fa_interface = {
114 aac_fa_get_fwstatus,
115 aac_fa_qnotify,
116 aac_fa_get_istatus,
117 aac_fa_clear_istatus,
118 aac_fa_set_mailbox,
119 aac_fa_get_mailbox,
120 aac_fa_set_interrupts
121};
122
123/* StrongARM interface */
124static int aac_sa_get_fwstatus(struct aac_softc *sc);
125static void aac_sa_qnotify(struct aac_softc *sc, int qbit);
126static int aac_sa_get_istatus(struct aac_softc *sc);
127static void aac_sa_clear_istatus(struct aac_softc *sc, int mask);
128static void aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command,
129 u_int32_t arg0, u_int32_t arg1,
130 u_int32_t arg2, u_int32_t arg3);
131static int aac_sa_get_mailbox(struct aac_softc *sc, int mb);
132static void aac_sa_set_interrupts(struct aac_softc *sc, int enable);
133
134struct aac_interface aac_sa_interface = {
135 aac_sa_get_fwstatus,
136 aac_sa_qnotify,
137 aac_sa_get_istatus,
138 aac_sa_clear_istatus,
139 aac_sa_set_mailbox,
140 aac_sa_get_mailbox,
141 aac_sa_set_interrupts
142};
143
144/* i960Rx interface */
145static int aac_rx_get_fwstatus(struct aac_softc *sc);
146static void aac_rx_qnotify(struct aac_softc *sc, int qbit);
147static int aac_rx_get_istatus(struct aac_softc *sc);
148static void aac_rx_clear_istatus(struct aac_softc *sc, int mask);
149static void aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command,
150 u_int32_t arg0, u_int32_t arg1,
151 u_int32_t arg2, u_int32_t arg3);
152static int aac_rx_get_mailbox(struct aac_softc *sc, int mb);
153static void aac_rx_set_interrupts(struct aac_softc *sc, int enable);
154
155struct aac_interface aac_rx_interface = {
156 aac_rx_get_fwstatus,
157 aac_rx_qnotify,
158 aac_rx_get_istatus,
159 aac_rx_clear_istatus,
160 aac_rx_set_mailbox,
161 aac_rx_get_mailbox,
162 aac_rx_set_interrupts
163};
164
165/* Debugging and Diagnostics */
166static void aac_describe_controller(struct aac_softc *sc);
167static char *aac_describe_code(struct aac_code_lookup *table,
168 u_int32_t code);
169
170/* Management Interface */
171static d_open_t aac_open;
172static d_close_t aac_close;
173static d_ioctl_t aac_ioctl;
174static d_poll_t aac_poll;
175static int aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib);
176static void aac_handle_aif(struct aac_softc *sc,
177 struct aac_fib *fib);
178static int aac_rev_check(struct aac_softc *sc, caddr_t udata);
179static int aac_getnext_aif(struct aac_softc *sc, caddr_t arg);
180static int aac_return_aif(struct aac_softc *sc, caddr_t uptr);
181static int aac_query_disk(struct aac_softc *sc, caddr_t uptr);
182
183static struct cdevsw aac_cdevsw = {
184 .d_open = aac_open,
185 .d_close = aac_close,
186 .d_ioctl = aac_ioctl,
187 .d_poll = aac_poll,
188 .d_name = "aac",
189};
190
191MALLOC_DEFINE(M_AACBUF, "aacbuf", "Buffers for the AAC driver");
192
193/* sysctl node */
194SYSCTL_NODE(_hw, OID_AUTO, aac, CTLFLAG_RD, 0, "AAC driver parameters");
195
196/*
197 * Device Interface
198 */
199
200/*
201 * Initialise the controller and softc
202 */
203int
204aac_attach(struct aac_softc *sc)
205{
206 int error, unit;
207
208 debug_called(1);
209
210 /*
211 * Initialise per-controller queues.
212 */
213 aac_initq_free(sc);
214 aac_initq_ready(sc);
215 aac_initq_busy(sc);
216 aac_initq_bio(sc);
217
218 /*
219 * Initialise command-completion task.
220 */
221 TASK_INIT(&sc->aac_task_complete, 0, aac_complete, sc);
222
223 /* disable interrupts before we enable anything */
224 AAC_MASK_INTERRUPTS(sc);
225
226 /* mark controller as suspended until we get ourselves organised */
227 sc->aac_state |= AAC_STATE_SUSPEND;
228
229 /*
230 * Check that the firmware on the card is supported.
231 */
232 if ((error = aac_check_firmware(sc)) != 0)
233 return(error);
234
235 /*
236 * Initialize locks
237 */
238 AAC_LOCK_INIT(&sc->aac_sync_lock, "AAC sync FIB lock");
239 AAC_LOCK_INIT(&sc->aac_aifq_lock, "AAC AIF lock");
240 AAC_LOCK_INIT(&sc->aac_io_lock, "AAC I/O lock");
241 AAC_LOCK_INIT(&sc->aac_container_lock, "AAC container lock");
242 TAILQ_INIT(&sc->aac_container_tqh);
243
244 /* Initialize the local AIF queue pointers */
245 sc->aac_aifq_head = sc->aac_aifq_tail = AAC_AIFQ_LENGTH;
246
247 /*
248 * Initialise the adapter.
249 */
250 if ((error = aac_init(sc)) != 0)
251 return(error);
252
253 /*
254 * Print a little information about the controller.
255 */
256 aac_describe_controller(sc);
257
258 /*
259 * Register to probe our containers later.
260 */
261 sc->aac_ich.ich_func = aac_startup;
262 sc->aac_ich.ich_arg = sc;
263 if (config_intrhook_establish(&sc->aac_ich) != 0) {
264 device_printf(sc->aac_dev,
265 "can't establish configuration hook\n");
266 return(ENXIO);
267 }
268
269 /*
270 * Make the control device.
271 */
272 unit = device_get_unit(sc->aac_dev);
273 sc->aac_dev_t = make_dev(&aac_cdevsw, unit, UID_ROOT, GID_OPERATOR,
274 0640, "aac%d", unit);
275 (void)make_dev_alias(sc->aac_dev_t, "afa%d", unit);
276 (void)make_dev_alias(sc->aac_dev_t, "hpn%d", unit);
277 sc->aac_dev_t->si_drv1 = sc;
278
279 /* Create the AIF thread */
280 if (kthread_create((void(*)(void *))aac_command_thread, sc,
281 &sc->aifthread, 0, 0, "aac%daif", unit))
282 panic("Could not create AIF thread\n");
283
284 /* Register the shutdown method to only be called post-dump */
285 if ((sc->eh = EVENTHANDLER_REGISTER(shutdown_final, aac_shutdown,
286 sc->aac_dev, SHUTDOWN_PRI_DEFAULT)) == NULL)
287 device_printf(sc->aac_dev,
288 "shutdown event registration failed\n");
289
290 /* Register with CAM for the non-DASD devices */
291 if ((sc->flags & AAC_FLAGS_ENABLE_CAM) != 0) {
292 TAILQ_INIT(&sc->aac_sim_tqh);
293 aac_get_bus_info(sc);
294 }
295
296 return(0);
297}
298
299/*
300 * Probe for containers, create disks.
301 */
302static void
303aac_startup(void *arg)
304{
305 struct aac_softc *sc;
306 struct aac_fib *fib;
307 struct aac_mntinfo *mi;
308 struct aac_mntinforesp *mir = NULL;
309 int count = 0, i = 0;
310
311 debug_called(1);
312
313 sc = (struct aac_softc *)arg;
314
315 /* disconnect ourselves from the intrhook chain */
316 config_intrhook_disestablish(&sc->aac_ich);
317
318 aac_alloc_sync_fib(sc, &fib, 0);
319 mi = (struct aac_mntinfo *)&fib->data[0];
320
321 /* loop over possible containers */
322 do {
323 /* request information on this container */
324 bzero(mi, sizeof(struct aac_mntinfo));
325 mi->Command = VM_NameServe;
326 mi->MntType = FT_FILESYS;
327 mi->MntCount = i;
328 if (aac_sync_fib(sc, ContainerCommand, 0, fib,
329 sizeof(struct aac_mntinfo))) {
330 printf("error probing container %d", i);
331 continue;
332 }
333
334 mir = (struct aac_mntinforesp *)&fib->data[0];
335 /* XXX Need to check if count changed */
336 count = mir->MntRespCount;
337 aac_add_container(sc, mir, 0);
338 i++;
339 } while ((i < count) && (i < AAC_MAX_CONTAINERS));
340
341 aac_release_sync_fib(sc);
342
343 /* poke the bus to actually attach the child devices */
344 if (bus_generic_attach(sc->aac_dev))
345 device_printf(sc->aac_dev, "bus_generic_attach failed\n");
346
347 /* mark the controller up */
348 sc->aac_state &= ~AAC_STATE_SUSPEND;
349
350 /* enable interrupts now */
351 AAC_UNMASK_INTERRUPTS(sc);
352}
353
354/*
355 * Create a device to respresent a new container
356 */
357static void
358aac_add_container(struct aac_softc *sc, struct aac_mntinforesp *mir, int f)
359{
360 struct aac_container *co;
361 device_t child;
362
363 /*
364 * Check container volume type for validity. Note that many of
365 * the possible types may never show up.
366 */
367 if ((mir->Status == ST_OK) && (mir->MntTable[0].VolType != CT_NONE)) {
368 co = (struct aac_container *)malloc(sizeof *co, M_AACBUF,
369 M_NOWAIT | M_ZERO);
370 if (co == NULL)
371 panic("Out of memory?!\n");
372 debug(1, "id %x name '%.16s' size %u type %d",
373 mir->MntTable[0].ObjectId,
374 mir->MntTable[0].FileSystemName,
375 mir->MntTable[0].Capacity, mir->MntTable[0].VolType);
376
377 if ((child = device_add_child(sc->aac_dev, "aacd", -1)) == NULL)
378 device_printf(sc->aac_dev, "device_add_child failed\n");
379 else
380 device_set_ivars(child, co);
381 device_set_desc(child, aac_describe_code(aac_container_types,
382 mir->MntTable[0].VolType));
383 co->co_disk = child;
384 co->co_found = f;
385 bcopy(&mir->MntTable[0], &co->co_mntobj,
386 sizeof(struct aac_mntobj));
387 AAC_LOCK_ACQUIRE(&sc->aac_container_lock);
388 TAILQ_INSERT_TAIL(&sc->aac_container_tqh, co, co_link);
389 AAC_LOCK_RELEASE(&sc->aac_container_lock);
390 }
391}
392
393/*
394 * Free all of the resources associated with (sc)
395 *
396 * Should not be called if the controller is active.
397 */
398void
399aac_free(struct aac_softc *sc)
400{
401
402 debug_called(1);
403
404 /* remove the control device */
405 if (sc->aac_dev_t != NULL)
406 destroy_dev(sc->aac_dev_t);
407
408 /* throw away any FIB buffers, discard the FIB DMA tag */
409 aac_free_commands(sc);
410 if (sc->aac_fib_dmat)
411 bus_dma_tag_destroy(sc->aac_fib_dmat);
412
413 free(sc->aac_commands, M_AACBUF);
414
415 /* destroy the common area */
416 if (sc->aac_common) {
417 bus_dmamap_unload(sc->aac_common_dmat, sc->aac_common_dmamap);
418 bus_dmamem_free(sc->aac_common_dmat, sc->aac_common,
419 sc->aac_common_dmamap);
420 }
421 if (sc->aac_common_dmat)
422 bus_dma_tag_destroy(sc->aac_common_dmat);
423
424 /* disconnect the interrupt handler */
425 if (sc->aac_intr)
426 bus_teardown_intr(sc->aac_dev, sc->aac_irq, sc->aac_intr);
427 if (sc->aac_irq != NULL)
428 bus_release_resource(sc->aac_dev, SYS_RES_IRQ, sc->aac_irq_rid,
429 sc->aac_irq);
430
431 /* destroy data-transfer DMA tag */
432 if (sc->aac_buffer_dmat)
433 bus_dma_tag_destroy(sc->aac_buffer_dmat);
434
435 /* destroy the parent DMA tag */
436 if (sc->aac_parent_dmat)
437 bus_dma_tag_destroy(sc->aac_parent_dmat);
438
439 /* release the register window mapping */
440 if (sc->aac_regs_resource != NULL)
441 bus_release_resource(sc->aac_dev, SYS_RES_MEMORY,
442 sc->aac_regs_rid, sc->aac_regs_resource);
443}
444
445/*
446 * Disconnect from the controller completely, in preparation for unload.
447 */
448int
449aac_detach(device_t dev)
450{
451 struct aac_softc *sc;
452 struct aac_container *co;
453 struct aac_sim *sim;
454 int error;
455
456 debug_called(1);
457
458 sc = device_get_softc(dev);
459
460 if (sc->aac_state & AAC_STATE_OPEN)
461 return(EBUSY);
462
463 /* Remove the child containers */
464 while ((co = TAILQ_FIRST(&sc->aac_container_tqh)) != NULL) {
465 error = device_delete_child(dev, co->co_disk);
466 if (error)
467 return (error);
468 TAILQ_REMOVE(&sc->aac_container_tqh, co, co_link);
469 free(co, M_AACBUF);
470 }
471
472 /* Remove the CAM SIMs */
473 while ((sim = TAILQ_FIRST(&sc->aac_sim_tqh)) != NULL) {
474 TAILQ_REMOVE(&sc->aac_sim_tqh, sim, sim_link);
475 error = device_delete_child(dev, sim->sim_dev);
476 if (error)
477 return (error);
478 free(sim, M_AACBUF);
479 }
480
481 if (sc->aifflags & AAC_AIFFLAGS_RUNNING) {
482 sc->aifflags |= AAC_AIFFLAGS_EXIT;
483 wakeup(sc->aifthread);
484 tsleep(sc->aac_dev, PUSER | PCATCH, "aacdch", 30 * hz);
485 }
486
487 if (sc->aifflags & AAC_AIFFLAGS_RUNNING)
488 panic("Cannot shutdown AIF thread\n");
489
490 if ((error = aac_shutdown(dev)))
491 return(error);
492
493 EVENTHANDLER_DEREGISTER(shutdown_final, sc->eh);
494
495 aac_free(sc);
496
497 return(0);
498}
499
500/*
501 * Bring the controller down to a dormant state and detach all child devices.
502 *
503 * This function is called before detach or system shutdown.
504 *
505 * Note that we can assume that the bioq on the controller is empty, as we won't
506 * allow shutdown if any device is open.
507 */
508int
509aac_shutdown(device_t dev)
510{
511 struct aac_softc *sc;
512 struct aac_fib *fib;
513 struct aac_close_command *cc;
514
515 debug_called(1);
516
517 sc = device_get_softc(dev);
518
519 sc->aac_state |= AAC_STATE_SUSPEND;
520
521 /*
522 * Send a Container shutdown followed by a HostShutdown FIB to the
523 * controller to convince it that we don't want to talk to it anymore.
524 * We've been closed and all I/O completed already
525 */
526 device_printf(sc->aac_dev, "shutting down controller...");
527
528 aac_alloc_sync_fib(sc, &fib, AAC_SYNC_LOCK_FORCE);
529 cc = (struct aac_close_command *)&fib->data[0];
530
531 bzero(cc, sizeof(struct aac_close_command));
532 cc->Command = VM_CloseAll;
533 cc->ContainerId = 0xffffffff;
534 if (aac_sync_fib(sc, ContainerCommand, 0, fib,
535 sizeof(struct aac_close_command)))
536 printf("FAILED.\n");
537 else
538 printf("done\n");
539#if 0
540 else {
541 fib->data[0] = 0;
542 /*
543 * XXX Issuing this command to the controller makes it shut down
544 * but also keeps it from coming back up without a reset of the
545 * PCI bus. This is not desirable if you are just unloading the
546 * driver module with the intent to reload it later.
547 */
548 if (aac_sync_fib(sc, FsaHostShutdown, AAC_FIBSTATE_SHUTDOWN,
549 fib, 1)) {
550 printf("FAILED.\n");
551 } else {
552 printf("done.\n");
553 }
554 }
555#endif
556
557 AAC_MASK_INTERRUPTS(sc);
558
559 return(0);
560}
561
562/*
563 * Bring the controller to a quiescent state, ready for system suspend.
564 */
565int
566aac_suspend(device_t dev)
567{
568 struct aac_softc *sc;
569
570 debug_called(1);
571
572 sc = device_get_softc(dev);
573
574 sc->aac_state |= AAC_STATE_SUSPEND;
575
576 AAC_MASK_INTERRUPTS(sc);
577 return(0);
578}
579
580/*
581 * Bring the controller back to a state ready for operation.
582 */
583int
584aac_resume(device_t dev)
585{
586 struct aac_softc *sc;
587
588 debug_called(1);
589
590 sc = device_get_softc(dev);
591
592 sc->aac_state &= ~AAC_STATE_SUSPEND;
593 AAC_UNMASK_INTERRUPTS(sc);
594 return(0);
595}
596
597/*
598 * Take an interrupt.
599 */
600void
601aac_intr(void *arg)
602{
603 struct aac_softc *sc;
604 u_int16_t reason;
605
606 debug_called(2);
607
608 sc = (struct aac_softc *)arg;
609
610 /*
611 * Read the status register directly. This is faster than taking the
612 * driver lock and reading the queues directly. It also saves having
613 * to turn parts of the driver lock into a spin mutex, which would be
614 * ugly.
615 */
616 reason = AAC_GET_ISTATUS(sc);
617 AAC_CLEAR_ISTATUS(sc, reason);
618
619 /* handle completion processing */
620 if (reason & AAC_DB_RESPONSE_READY)
621 taskqueue_enqueue_fast(taskqueue_fast, &sc->aac_task_complete);
622
623 /* controller wants to talk to us */
624 if (reason & (AAC_DB_PRINTF | AAC_DB_COMMAND_READY)) {
625 /*
626 * XXX Make sure that we don't get fooled by strange messages
627 * that start with a NULL.
628 */
629 if ((reason & AAC_DB_PRINTF) &&
630 (sc->aac_common->ac_printf[0] == 0))
631 sc->aac_common->ac_printf[0] = 32;
632
633 /*
634 * This might miss doing the actual wakeup. However, the
635 * msleep that this is waking up has a timeout, so it will
636 * wake up eventually. AIFs and printfs are low enough
637 * priority that they can handle hanging out for a few seconds
638 * if needed.
639 */
640 wakeup(sc->aifthread);
641 }
642}
643
644/*
645 * Command Processing
646 */
647
648/*
649 * Start as much queued I/O as possible on the controller
650 */
651void
652aac_startio(struct aac_softc *sc)
653{
654 struct aac_command *cm;
655
656 debug_called(2);
657
658 if (sc->flags & AAC_QUEUE_FRZN)
659 return;
660
661 for (;;) {
662 /*
663 * Try to get a command that's been put off for lack of
664 * resources
665 */
666 cm = aac_dequeue_ready(sc);
667
668 /*
669 * Try to build a command off the bio queue (ignore error
670 * return)
671 */
672 if (cm == NULL)
673 aac_bio_command(sc, &cm);
674
675 /* nothing to do? */
676 if (cm == NULL)
677 break;
678
679 /*
680 * Try to give the command to the controller. Any error is
681 * catastrophic since it means that bus_dmamap_load() failed.
682 */
683 if (aac_map_command(cm) != 0)
684 panic("aac: error mapping command %p\n", cm);
685 }
686}
687
688/*
689 * Deliver a command to the controller; allocate controller resources at the
690 * last moment when possible.
691 */
692static int
693aac_map_command(struct aac_command *cm)
694{
695 struct aac_softc *sc;
696 int error;
697
698 debug_called(2);
699
700 sc = cm->cm_sc;
701 error = 0;
702
703 /* don't map more than once */
704 if (cm->cm_flags & AAC_CMD_MAPPED)
705 panic("aac: command %p already mapped", cm);
706
707 if (cm->cm_datalen != 0) {
708 error = bus_dmamap_load(sc->aac_buffer_dmat, cm->cm_datamap,
709 cm->cm_data, cm->cm_datalen,
710 aac_map_command_sg, cm, 0);
711 if (error == EINPROGRESS) {
712 debug(1, "freezing queue\n");
713 sc->flags |= AAC_QUEUE_FRZN;
714 error = 0;
715 }
716 } else {
717 aac_map_command_sg(cm, NULL, 0, 0);
718 }
719 return (error);
720}
721
722/*
723 * Handle notification of one or more FIBs coming from the controller.
724 */
725static void
726aac_command_thread(struct aac_softc *sc)
727{
728 struct aac_fib *fib;
729 u_int32_t fib_size;
730 int size, retval;
731
732 debug_called(2);
733
734 AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
735 sc->aifflags = AAC_AIFFLAGS_RUNNING;
736
737 while ((sc->aifflags & AAC_AIFFLAGS_EXIT) == 0) {
738
739 retval = 0;
740 if ((sc->aifflags & AAC_AIFFLAGS_PENDING) == 0)
741 retval = msleep(sc->aifthread, &sc->aac_io_lock, PRIBIO,
742 "aifthd", AAC_PERIODIC_INTERVAL * hz);
743
744 /*
745 * First see if any FIBs need to be allocated. This needs
746 * to be called without the driver lock because contigmalloc
747 * will grab Giant, and would result in an LOR.
748 */
749 if ((sc->aifflags & AAC_AIFFLAGS_ALLOCFIBS) != 0) {
750 AAC_LOCK_RELEASE(&sc->aac_io_lock);
751 aac_alloc_commands(sc);
752 AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
753 sc->aifflags &= ~AAC_AIFFLAGS_ALLOCFIBS;
754 aac_startio(sc);
755 }
756
757 /*
758 * While we're here, check to see if any commands are stuck.
759 * This is pretty low-priority, so it's ok if it doesn't
760 * always fire.
761 */
762 if (retval == EWOULDBLOCK)
763 aac_timeout(sc);
764
765 /* Check the hardware printf message buffer */
766 if (sc->aac_common->ac_printf[0] != 0)
767 aac_print_printf(sc);
768
769 /* Also check to see if the adapter has a command for us. */
770 while (aac_dequeue_fib(sc, AAC_HOST_NORM_CMD_QUEUE,
771 &fib_size, &fib) == 0) {
772
773 AAC_PRINT_FIB(sc, fib);
774
775 switch (fib->Header.Command) {
776 case AifRequest:
777 aac_handle_aif(sc, fib);
778 break;
779 default:
780 device_printf(sc->aac_dev, "unknown command "
781 "from controller\n");
782 break;
783 }
784
785 if ((fib->Header.XferState == 0) ||
786 (fib->Header.StructType != AAC_FIBTYPE_TFIB))
787 break;
788
789 /* Return the AIF to the controller. */
790 if (fib->Header.XferState & AAC_FIBSTATE_FROMADAP) {
791 fib->Header.XferState |= AAC_FIBSTATE_DONEHOST;
792 *(AAC_FSAStatus*)fib->data = ST_OK;
793
794 /* XXX Compute the Size field? */
795 size = fib->Header.Size;
796 if (size > sizeof(struct aac_fib)) {
797 size = sizeof(struct aac_fib);
798 fib->Header.Size = size;
799 }
800 /*
801 * Since we did not generate this command, it
802 * cannot go through the normal
803 * enqueue->startio chain.
804 */
805 aac_enqueue_response(sc,
806 AAC_ADAP_NORM_RESP_QUEUE,
807 fib);
808 }
809 }
810 }
811 sc->aifflags &= ~AAC_AIFFLAGS_RUNNING;
812 AAC_LOCK_RELEASE(&sc->aac_io_lock);
813 wakeup(sc->aac_dev);
814
815 mtx_lock(&Giant);
816 kthread_exit(0);
817}
818
819/*
820 * Process completed commands.
821 */
822static void
823aac_complete(void *context, int pending)
824{
825 struct aac_softc *sc;
826 struct aac_command *cm;
827 struct aac_fib *fib;
828 u_int32_t fib_size;
829
830 debug_called(2);
831
832 sc = (struct aac_softc *)context;
833
834 AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
835
836 /* pull completed commands off the queue */
837 for (;;) {
838 /* look for completed FIBs on our queue */
839 if (aac_dequeue_fib(sc, AAC_HOST_NORM_RESP_QUEUE, &fib_size,
840 &fib))
841 break; /* nothing to do */
842
843 /* get the command, unmap and hand off for processing */
844 cm = sc->aac_commands + fib->Header.SenderData;
845 if (cm == NULL) {
846 AAC_PRINT_FIB(sc, fib);
847 break;
848 }
849
850 aac_remove_busy(cm);
851 aac_unmap_command(cm);
852 cm->cm_flags |= AAC_CMD_COMPLETED;
853
854 /* is there a completion handler? */
855 if (cm->cm_complete != NULL) {
856 cm->cm_complete(cm);
857 } else {
858 /* assume that someone is sleeping on this command */
859 wakeup(cm);
860 }
861 }
862
863 /* see if we can start some more I/O */
864 sc->flags &= ~AAC_QUEUE_FRZN;
865 aac_startio(sc);
866
867 AAC_LOCK_RELEASE(&sc->aac_io_lock);
868}
869
870/*
871 * Handle a bio submitted from a disk device.
872 */
873void
874aac_submit_bio(struct bio *bp)
875{
876 struct aac_disk *ad;
877 struct aac_softc *sc;
878
879 debug_called(2);
880
881 ad = (struct aac_disk *)bp->bio_disk->d_drv1;
882 sc = ad->ad_controller;
883
884 /* queue the BIO and try to get some work done */
885 aac_enqueue_bio(sc, bp);
886 aac_startio(sc);
887}
888
889/*
890 * Get a bio and build a command to go with it.
891 */
892static int
893aac_bio_command(struct aac_softc *sc, struct aac_command **cmp)
894{
895 struct aac_command *cm;
896 struct aac_fib *fib;
897 struct aac_disk *ad;
898 struct bio *bp;
899
900 debug_called(2);
901
902 /* get the resources we will need */
903 cm = NULL;
904 bp = NULL;
905 if (aac_alloc_command(sc, &cm)) /* get a command */
906 goto fail;
907 if ((bp = aac_dequeue_bio(sc)) == NULL)
908 goto fail;
909
910 /* fill out the command */
911 cm->cm_data = (void *)bp->bio_data;
912 cm->cm_datalen = bp->bio_bcount;
913 cm->cm_complete = aac_bio_complete;
914 cm->cm_private = bp;
915 cm->cm_timestamp = time_second;
916 cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE;
917
918 /* build the FIB */
919 fib = cm->cm_fib;
920 fib->Header.Size = sizeof(struct aac_fib_header);
921 fib->Header.XferState =
922 AAC_FIBSTATE_HOSTOWNED |
923 AAC_FIBSTATE_INITIALISED |
924 AAC_FIBSTATE_EMPTY |
925 AAC_FIBSTATE_FROMHOST |
926 AAC_FIBSTATE_REXPECTED |
927 AAC_FIBSTATE_NORM |
928 AAC_FIBSTATE_ASYNC |
929 AAC_FIBSTATE_FAST_RESPONSE;
930
931 /* build the read/write request */
932 ad = (struct aac_disk *)bp->bio_disk->d_drv1;
933
934 if ((sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
935 fib->Header.Command = ContainerCommand;
936 if (bp->bio_cmd == BIO_READ) {
937 struct aac_blockread *br;
938 br = (struct aac_blockread *)&fib->data[0];
939 br->Command = VM_CtBlockRead;
940 br->ContainerId = ad->ad_container->co_mntobj.ObjectId;
941 br->BlockNumber = bp->bio_pblkno;
942 br->ByteCount = bp->bio_bcount;
943 fib->Header.Size += sizeof(struct aac_blockread);
944 cm->cm_sgtable = &br->SgMap;
945 cm->cm_flags |= AAC_CMD_DATAIN;
946 } else {
947 struct aac_blockwrite *bw;
948 bw = (struct aac_blockwrite *)&fib->data[0];
949 bw->Command = VM_CtBlockWrite;
950 bw->ContainerId = ad->ad_container->co_mntobj.ObjectId;
951 bw->BlockNumber = bp->bio_pblkno;
952 bw->ByteCount = bp->bio_bcount;
953 bw->Stable = CUNSTABLE;
954 fib->Header.Size += sizeof(struct aac_blockwrite);
955 cm->cm_flags |= AAC_CMD_DATAOUT;
956 cm->cm_sgtable = &bw->SgMap;
957 }
958 } else {
959 fib->Header.Command = ContainerCommand64;
960 if (bp->bio_cmd == BIO_READ) {
961 struct aac_blockread64 *br;
962 br = (struct aac_blockread64 *)&fib->data[0];
963 br->Command = VM_CtHostRead64;
964 br->ContainerId = ad->ad_container->co_mntobj.ObjectId;
965 br->SectorCount = bp->bio_bcount / AAC_BLOCK_SIZE;
966 br->BlockNumber = bp->bio_pblkno;
967 br->Pad = 0;
968 br->Flags = 0;
969 fib->Header.Size += sizeof(struct aac_blockread64);
970 cm->cm_flags |= AAC_CMD_DATAOUT;
971 (struct aac_sg_table64 *)cm->cm_sgtable = &br->SgMap64;
972 } else {
973 struct aac_blockwrite64 *bw;
974 bw = (struct aac_blockwrite64 *)&fib->data[0];
975 bw->Command = VM_CtHostWrite64;
976 bw->ContainerId = ad->ad_container->co_mntobj.ObjectId;
977 bw->SectorCount = bp->bio_bcount / AAC_BLOCK_SIZE;
978 bw->BlockNumber = bp->bio_pblkno;
979 bw->Pad = 0;
980 bw->Flags = 0;
981 fib->Header.Size += sizeof(struct aac_blockwrite64);
982 cm->cm_flags |= AAC_CMD_DATAIN;
983 (struct aac_sg_table64 *)cm->cm_sgtable = &bw->SgMap64;
984 }
985 }
986
987 *cmp = cm;
988 return(0);
989
990fail:
991 if (bp != NULL)
992 aac_enqueue_bio(sc, bp);
993 if (cm != NULL)
994 aac_release_command(cm);
995 return(ENOMEM);
996}
997
998/*
999 * Handle a bio-instigated command that has been completed.
1000 */
1001static void
1002aac_bio_complete(struct aac_command *cm)
1003{
1004 struct aac_blockread_response *brr;
1005 struct aac_blockwrite_response *bwr;
1006 struct bio *bp;
1007 AAC_FSAStatus status;
1008
1009 /* fetch relevant status and then release the command */
1010 bp = (struct bio *)cm->cm_private;
1011 if (bp->bio_cmd == BIO_READ) {
1012 brr = (struct aac_blockread_response *)&cm->cm_fib->data[0];
1013 status = brr->Status;
1014 } else {
1015 bwr = (struct aac_blockwrite_response *)&cm->cm_fib->data[0];
1016 status = bwr->Status;
1017 }
1018 aac_release_command(cm);
1019
1020 /* fix up the bio based on status */
1021 if (status == ST_OK) {
1022 bp->bio_resid = 0;
1023 } else {
1024 bp->bio_error = EIO;
1025 bp->bio_flags |= BIO_ERROR;
1026 /* pass an error string out to the disk layer */
1027 bp->bio_driver1 = aac_describe_code(aac_command_status_table,
1028 status);
1029 }
1030 aac_biodone(bp);
1031}
1032
1033/*
1034 * Submit a command to the controller, return when it completes.
1035 * XXX This is very dangerous! If the card has gone out to lunch, we could
1036 * be stuck here forever. At the same time, signals are not caught
1037 * because there is a risk that a signal could wakeup the tsleep before
1038 * the card has a chance to complete the command. The passed in timeout
1039 * is ignored for the same reason. Since there is no way to cancel a
1040 * command in progress, we should probably create a 'dead' queue where
1041 * commands go that have been interrupted/timed-out/etc, that keeps them
1042 * out of the free pool. That way, if the card is just slow, it won't
1043 * spam the memory of a command that has been recycled.
1044 */
1045static int
1046aac_wait_command(struct aac_command *cm, int timeout)
1047{
1048 struct aac_softc *sc;
1049 int error = 0;
1050
1051 debug_called(2);
1052
1053 sc = cm->cm_sc;
1054
1055 /* Put the command on the ready queue and get things going */
1056 cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE;
1057 aac_enqueue_ready(cm);
1058 aac_startio(sc);
1059 while (!(cm->cm_flags & AAC_CMD_COMPLETED) && (error != EWOULDBLOCK)) {
1060 error = msleep(cm, &sc->aac_io_lock, PRIBIO, "aacwait", 0);
1061 }
1062 return(error);
1063}
1064
1065/*
1066 *Command Buffer Management
1067 */
1068
1069/*
1070 * Allocate a command.
1071 */
1072int
1073aac_alloc_command(struct aac_softc *sc, struct aac_command **cmp)
1074{
1075 struct aac_command *cm;
1076
1077 debug_called(3);
1078
1079 if ((cm = aac_dequeue_free(sc)) == NULL) {
1080 if (sc->total_fibs < sc->aac_max_fibs) {
1081 sc->aifflags |= AAC_AIFFLAGS_ALLOCFIBS;
1082 wakeup(sc->aifthread);
1083 }
1084 return (EBUSY);
1085 }
1086
1087 *cmp = cm;
1088 return(0);
1089}
1090
1091/*
1092 * Release a command back to the freelist.
1093 */
1094void
1095aac_release_command(struct aac_command *cm)
1096{
1097 debug_called(3);
1098
1099 /* (re)initialise the command/FIB */
1100 cm->cm_sgtable = NULL;
1101 cm->cm_flags = 0;
1102 cm->cm_complete = NULL;
1103 cm->cm_private = NULL;
1104 cm->cm_fib->Header.XferState = AAC_FIBSTATE_EMPTY;
1105 cm->cm_fib->Header.StructType = AAC_FIBTYPE_TFIB;
1106 cm->cm_fib->Header.Flags = 0;
1107 cm->cm_fib->Header.SenderSize = sizeof(struct aac_fib);
1108
1109 /*
1110 * These are duplicated in aac_start to cover the case where an
1111 * intermediate stage may have destroyed them. They're left
1112 * initialised here for debugging purposes only.
1113 */
1114 cm->cm_fib->Header.ReceiverFibAddress = (u_int32_t)cm->cm_fibphys;
1115 cm->cm_fib->Header.SenderData = 0;
1116
1117 aac_enqueue_free(cm);
1118}
1119
1120/*
1121 * Map helper for command/FIB allocation.
1122 */
1123static void
1124aac_map_command_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1125{
1126 uint32_t *fibphys;
1127
1128 fibphys = (uint32_t *)arg;
1129
1130 debug_called(3);
1131
1132 *fibphys = segs[0].ds_addr;
1133}
1134
1135/*
1136 * Allocate and initialise commands/FIBs for this adapter.
1137 */
1138static int
1139aac_alloc_commands(struct aac_softc *sc)
1140{
1141 struct aac_command *cm;
1142 struct aac_fibmap *fm;
1143 uint32_t fibphys;
1144 int i, error;
1145
1146 debug_called(2);
1147
1148 if (sc->total_fibs + AAC_FIB_COUNT > sc->aac_max_fibs)
1149 return (ENOMEM);
1150
1151 fm = malloc(sizeof(struct aac_fibmap), M_AACBUF, M_NOWAIT|M_ZERO);
1152 if (fm == NULL)
1153 return (ENOMEM);
1154
1155 /* allocate the FIBs in DMAable memory and load them */
1156 if (bus_dmamem_alloc(sc->aac_fib_dmat, (void **)&fm->aac_fibs,
1157 BUS_DMA_NOWAIT, &fm->aac_fibmap)) {
1158 device_printf(sc->aac_dev,
1159 "Not enough contiguous memory available.\n");
1160 free(fm, M_AACBUF);
1161 return (ENOMEM);
1162 }
1163
1164 /* Ignore errors since this doesn't bounce */
1165 (void)bus_dmamap_load(sc->aac_fib_dmat, fm->aac_fibmap, fm->aac_fibs,
1166 AAC_FIB_COUNT * sizeof(struct aac_fib),
1167 aac_map_command_helper, &fibphys, 0);
1168
1169 /* initialise constant fields in the command structure */
1170 AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
1171 bzero(fm->aac_fibs, AAC_FIB_COUNT * sizeof(struct aac_fib));
1172 for (i = 0; i < AAC_FIB_COUNT; i++) {
1173 cm = sc->aac_commands + sc->total_fibs;
1174 fm->aac_commands = cm;
1175 cm->cm_sc = sc;
1176 cm->cm_fib = fm->aac_fibs + i;
1177 cm->cm_fibphys = fibphys + (i * sizeof(struct aac_fib));
1178 cm->cm_index = sc->total_fibs;
1179
1180 if ((error = bus_dmamap_create(sc->aac_buffer_dmat, 0,
1181 &cm->cm_datamap)) == 0)
1182 aac_release_command(cm);
1183 else
1184 break;
1185 sc->total_fibs++;
1186 }
1187
1188 if (i > 0) {
1189 TAILQ_INSERT_TAIL(&sc->aac_fibmap_tqh, fm, fm_link);
1190 debug(1, "total_fibs= %d\n", sc->total_fibs);
1191 AAC_LOCK_RELEASE(&sc->aac_io_lock);
1192 return (0);
1193 }
1194
1195 AAC_LOCK_RELEASE(&sc->aac_io_lock);
1196 bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap);
1197 bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap);
1198 free(fm, M_AACBUF);
1199 return (ENOMEM);
1200}
1201
1202/*
1203 * Free FIBs owned by this adapter.
1204 */
1205static void
1206aac_free_commands(struct aac_softc *sc)
1207{
1208 struct aac_fibmap *fm;
1209 struct aac_command *cm;
1210 int i;
1211
1212 debug_called(1);
1213
1214 while ((fm = TAILQ_FIRST(&sc->aac_fibmap_tqh)) != NULL) {
1215
1216 TAILQ_REMOVE(&sc->aac_fibmap_tqh, fm, fm_link);
1217 /*
1218 * We check against total_fibs to handle partially
1219 * allocated blocks.
1220 */
1221 for (i = 0; i < AAC_FIB_COUNT && sc->total_fibs--; i++) {
1222 cm = fm->aac_commands + i;
1223 bus_dmamap_destroy(sc->aac_buffer_dmat, cm->cm_datamap);
1224 }
1225 bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap);
1226 bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap);
1227 free(fm, M_AACBUF);
1228 }
1229}
1230
1231/*
1232 * Command-mapping helper function - populate this command's s/g table.
1233 */
1234static void
1235aac_map_command_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1236{
1237 struct aac_softc *sc;
1238 struct aac_command *cm;
1239 struct aac_fib *fib;
1240 int i;
1241
1242 debug_called(3);
1243
1244 cm = (struct aac_command *)arg;
1245 sc = cm->cm_sc;
1246 fib = cm->cm_fib;
1247
1248 /* copy into the FIB */
1249 if (cm->cm_sgtable != NULL) {
1250 if ((cm->cm_sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
1251 struct aac_sg_table *sg;
1252 sg = cm->cm_sgtable;
1253 sg->SgCount = nseg;
1254 for (i = 0; i < nseg; i++) {
1255 sg->SgEntry[i].SgAddress = segs[i].ds_addr;
1256 sg->SgEntry[i].SgByteCount = segs[i].ds_len;
1257 }
1258 /* update the FIB size for the s/g count */
1259 fib->Header.Size += nseg * sizeof(struct aac_sg_entry);
1260 } else {
1261 struct aac_sg_table64 *sg;
1262 sg = (struct aac_sg_table64 *)cm->cm_sgtable;
1263 sg->SgCount = nseg;
1264 for (i = 0; i < nseg; i++) {
1265 sg->SgEntry64[i].SgAddress = segs[i].ds_addr;
1266 sg->SgEntry64[i].SgByteCount = segs[i].ds_len;
1267 }
1268 /* update the FIB size for the s/g count */
1269 fib->Header.Size += nseg*sizeof(struct aac_sg_entry64);
1270 }
1271 }
1272
1273 /* Fix up the address values in the FIB. Use the command array index
1274 * instead of a pointer since these fields are only 32 bits. Shift
1275 * the SenderFibAddress over to make room for the fast response bit.
1276 */
1277 cm->cm_fib->Header.SenderFibAddress = (cm->cm_index << 1);
1278 cm->cm_fib->Header.ReceiverFibAddress = cm->cm_fibphys;
1279
1280 /* save a pointer to the command for speedy reverse-lookup */
1281 cm->cm_fib->Header.SenderData = cm->cm_index;
1282
1283 if (cm->cm_flags & AAC_CMD_DATAIN)
1284 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1285 BUS_DMASYNC_PREREAD);
1286 if (cm->cm_flags & AAC_CMD_DATAOUT)
1287 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1288 BUS_DMASYNC_PREWRITE);
1289 cm->cm_flags |= AAC_CMD_MAPPED;
1290
1291 /* put the FIB on the outbound queue */
1292 if (aac_enqueue_fib(sc, cm->cm_queue, cm) == EBUSY) {
1293 aac_unmap_command(cm);
1294 aac_requeue_ready(cm);
1295 }
1296
1297 return;
1298}
1299
1300/*
1301 * Unmap a command from controller-visible space.
1302 */
1303static void
1304aac_unmap_command(struct aac_command *cm)
1305{
1306 struct aac_softc *sc;
1307
1308 debug_called(2);
1309
1310 sc = cm->cm_sc;
1311
1312 if (!(cm->cm_flags & AAC_CMD_MAPPED))
1313 return;
1314
1315 if (cm->cm_datalen != 0) {
1316 if (cm->cm_flags & AAC_CMD_DATAIN)
1317 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1318 BUS_DMASYNC_POSTREAD);
1319 if (cm->cm_flags & AAC_CMD_DATAOUT)
1320 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1321 BUS_DMASYNC_POSTWRITE);
1322
1323 bus_dmamap_unload(sc->aac_buffer_dmat, cm->cm_datamap);
1324 }
1325 cm->cm_flags &= ~AAC_CMD_MAPPED;
1326}
1327
1328/*
1329 * Hardware Interface
1330 */
1331
1332/*
1333 * Initialise the adapter.
1334 */
1335static void
1336aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1337{
1338 struct aac_softc *sc;
1339
1340 debug_called(1);
1341
1342 sc = (struct aac_softc *)arg;
1343
1344 sc->aac_common_busaddr = segs[0].ds_addr;
1345}
1346
1347static int
1348aac_check_firmware(struct aac_softc *sc)
1349{
1350 u_int32_t major, minor, options;
1351
1352 debug_called(1);
1353
1354 /*
1355 * Retrieve the firmware version numbers. Dell PERC2/QC cards with
1356 * firmware version 1.x are not compatible with this driver.
1357 */
1358 if (sc->flags & AAC_FLAGS_PERC2QC) {
1359 if (aac_sync_command(sc, AAC_MONKER_GETKERNVER, 0, 0, 0, 0,
1360 NULL)) {
1361 device_printf(sc->aac_dev,
1362 "Error reading firmware version\n");
1363 return (EIO);
1364 }
1365
1366 /* These numbers are stored as ASCII! */
1367 major = (AAC_GET_MAILBOX(sc, 1) & 0xff) - 0x30;
1368 minor = (AAC_GET_MAILBOX(sc, 2) & 0xff) - 0x30;
1369 if (major == 1) {
1370 device_printf(sc->aac_dev,
1371 "Firmware version %d.%d is not supported.\n",
1372 major, minor);
1373 return (EINVAL);
1374 }
1375 }
1376
1377 /*
1378 * Retrieve the capabilities/supported options word so we know what
1379 * work-arounds to enable.
1380 */
1381 if (aac_sync_command(sc, AAC_MONKER_GETINFO, 0, 0, 0, 0, NULL)) {
1382 device_printf(sc->aac_dev, "RequestAdapterInfo failed\n");
1383 return (EIO);
1384 }
1385 options = AAC_GET_MAILBOX(sc, 1);
1386 sc->supported_options = options;
1387
1388 if ((options & AAC_SUPPORTED_4GB_WINDOW) != 0 &&
1389 (sc->flags & AAC_FLAGS_NO4GB) == 0)
1390 sc->flags |= AAC_FLAGS_4GB_WINDOW;
1391 if (options & AAC_SUPPORTED_NONDASD)
1392 sc->flags |= AAC_FLAGS_ENABLE_CAM;
1393 if ((options & AAC_SUPPORTED_SGMAP_HOST64) != 0
1394 && (sizeof(bus_addr_t) > 4)) {
1395 device_printf(sc->aac_dev, "Enabling 64-bit address support\n");
1396 sc->flags |= AAC_FLAGS_SG_64BIT;
1397 }
1398
1399 /* Check for broken hardware that does a lower number of commands */
1400 if ((sc->flags & AAC_FLAGS_256FIBS) == 0)
1401 sc->aac_max_fibs = AAC_MAX_FIBS;
1402 else
1403 sc->aac_max_fibs = 256;
1404
1405 return (0);
1406}
1407
1408static int
1409aac_init(struct aac_softc *sc)
1410{
1411 struct aac_adapter_init *ip;
1412 time_t then;
1413 u_int32_t code, qoffset;
1414 int error;
1415
1416 debug_called(1);
1417
1418 /*
1419 * First wait for the adapter to come ready.
1420 */
1421 then = time_second;
1422 do {
1423 code = AAC_GET_FWSTATUS(sc);
1424 if (code & AAC_SELF_TEST_FAILED) {
1425 device_printf(sc->aac_dev, "FATAL: selftest failed\n");
1426 return(ENXIO);
1427 }
1428 if (code & AAC_KERNEL_PANIC) {
1429 device_printf(sc->aac_dev,
1430 "FATAL: controller kernel panic\n");
1431 return(ENXIO);
1432 }
1433 if (time_second > (then + AAC_BOOT_TIMEOUT)) {
1434 device_printf(sc->aac_dev,
1435 "FATAL: controller not coming ready, "
1436 "status %x\n", code);
1437 return(ENXIO);
1438 }
1439 } while (!(code & AAC_UP_AND_RUNNING));
1440
1441 error = ENOMEM;
1442 /*
1443 * Create DMA tag for mapping buffers into controller-addressable space.
1444 */
1445 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
1446 1, 0, /* algnmnt, boundary */
1447 (sc->flags & AAC_FLAGS_SG_64BIT) ?
1448 BUS_SPACE_MAXADDR :
1449 BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
1450 BUS_SPACE_MAXADDR, /* highaddr */
1451 NULL, NULL, /* filter, filterarg */
1452 MAXBSIZE, /* maxsize */
1453 AAC_MAXSGENTRIES, /* nsegments */
1454 MAXBSIZE, /* maxsegsize */
1455 BUS_DMA_ALLOCNOW, /* flags */
1456 busdma_lock_mutex, /* lockfunc */
1457 &sc->aac_io_lock, /* lockfuncarg */
1458 &sc->aac_buffer_dmat)) {
1459 device_printf(sc->aac_dev, "can't allocate buffer DMA tag\n");
1460 goto out;
1461 }
1462
1463 /*
1464 * Create DMA tag for mapping FIBs into controller-addressable space..
1465 */
1466 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
1467 1, 0, /* algnmnt, boundary */
1468 (sc->flags & AAC_FLAGS_4GB_WINDOW) ?
1469 BUS_SPACE_MAXADDR_32BIT :
1470 0x7fffffff, /* lowaddr */
1471 BUS_SPACE_MAXADDR, /* highaddr */
1472 NULL, NULL, /* filter, filterarg */
1473 AAC_FIB_COUNT *
1474 sizeof(struct aac_fib), /* maxsize */
1475 1, /* nsegments */
1476 AAC_FIB_COUNT *
1477 sizeof(struct aac_fib), /* maxsegsize */
1478 BUS_DMA_ALLOCNOW, /* flags */
1479 NULL, NULL, /* No locking needed */
1480 &sc->aac_fib_dmat)) {
1481 device_printf(sc->aac_dev, "can't allocate FIB DMA tag\n");;
1482 goto out;
1483 }
1484
1485 /*
1486 * Create DMA tag for the common structure and allocate it.
1487 */
1488 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
1489 1, 0, /* algnmnt, boundary */
1490 (sc->flags & AAC_FLAGS_4GB_WINDOW) ?
1491 BUS_SPACE_MAXADDR_32BIT :
1492 0x7fffffff, /* lowaddr */
1493 BUS_SPACE_MAXADDR, /* highaddr */
1494 NULL, NULL, /* filter, filterarg */
1495 8192 + sizeof(struct aac_common), /* maxsize */
1496 1, /* nsegments */
1497 BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
1498 BUS_DMA_ALLOCNOW, /* flags */
1499 NULL, NULL, /* No locking needed */
1500 &sc->aac_common_dmat)) {
1501 device_printf(sc->aac_dev,
1502 "can't allocate common structure DMA tag\n");
1503 goto out;
1504 }
1505 if (bus_dmamem_alloc(sc->aac_common_dmat, (void **)&sc->aac_common,
1506 BUS_DMA_NOWAIT, &sc->aac_common_dmamap)) {
1507 device_printf(sc->aac_dev, "can't allocate common structure\n");
1508 goto out;
1509 }
1510
1511 /*
1512 * Work around a bug in the 2120 and 2200 that cannot DMA commands
1513 * below address 8192 in physical memory.
1514 * XXX If the padding is not needed, can it be put to use instead
1515 * of ignored?
1516 */
1517 (void)bus_dmamap_load(sc->aac_common_dmat, sc->aac_common_dmamap,
1518 sc->aac_common, 8192 + sizeof(*sc->aac_common),
1519 aac_common_map, sc, 0);
1520
1521 if (sc->aac_common_busaddr < 8192) {
1522 (uint8_t *)sc->aac_common += 8192;
1523 sc->aac_common_busaddr += 8192;
1524 }
1525 bzero(sc->aac_common, sizeof(*sc->aac_common));
1526
1527 /* Allocate some FIBs and associated command structs */
1528 TAILQ_INIT(&sc->aac_fibmap_tqh);
1529 sc->aac_commands = malloc(AAC_MAX_FIBS * sizeof(struct aac_command),
1530 M_AACBUF, M_WAITOK|M_ZERO);
1531 while (sc->total_fibs < AAC_PREALLOCATE_FIBS) {
1532 if (aac_alloc_commands(sc) != 0)
1533 break;
1534 }
1535 if (sc->total_fibs == 0)
1536 goto out;
1537
1538 /*
1539 * Fill in the init structure. This tells the adapter about the
1540 * physical location of various important shared data structures.
1541 */
1542 ip = &sc->aac_common->ac_init;
1543 ip->InitStructRevision = AAC_INIT_STRUCT_REVISION;
1544 ip->MiniPortRevision = AAC_INIT_STRUCT_MINIPORT_REVISION;
1545
1546 ip->AdapterFibsPhysicalAddress = sc->aac_common_busaddr +
1547 offsetof(struct aac_common, ac_fibs);
1548 ip->AdapterFibsVirtualAddress = 0;
1549 ip->AdapterFibsSize = AAC_ADAPTER_FIBS * sizeof(struct aac_fib);
1550 ip->AdapterFibAlign = sizeof(struct aac_fib);
1551
1552 ip->PrintfBufferAddress = sc->aac_common_busaddr +
1553 offsetof(struct aac_common, ac_printf);
1554 ip->PrintfBufferSize = AAC_PRINTF_BUFSIZE;
1555
1556 /*
1557 * The adapter assumes that pages are 4K in size, except on some
1558 * broken firmware versions that do the page->byte conversion twice,
1559 * therefore 'assuming' that this value is in 16MB units (2^24).
1560 * Round up since the granularity is so high.
1561 */
1562 ip->HostPhysMemPages = ctob(physmem) / AAC_PAGE_SIZE;
1563 if (sc->flags & AAC_FLAGS_BROKEN_MEMMAP) {
1564 ip->HostPhysMemPages =
1565 (ip->HostPhysMemPages + AAC_PAGE_SIZE) / AAC_PAGE_SIZE;
1566 }
1567 ip->HostElapsedSeconds = time_second; /* reset later if invalid */
1568
1569 /*
1570 * Initialise FIB queues. Note that it appears that the layout of the
1571 * indexes and the segmentation of the entries may be mandated by the
1572 * adapter, which is only told about the base of the queue index fields.
1573 *
1574 * The initial values of the indices are assumed to inform the adapter
1575 * of the sizes of the respective queues, and theoretically it could
1576 * work out the entire layout of the queue structures from this. We
1577 * take the easy route and just lay this area out like everyone else
1578 * does.
1579 *
1580 * The Linux driver uses a much more complex scheme whereby several
1581 * header records are kept for each queue. We use a couple of generic
1582 * list manipulation functions which 'know' the size of each list by
1583 * virtue of a table.
1584 */
1585 qoffset = offsetof(struct aac_common, ac_qbuf) + AAC_QUEUE_ALIGN;
1586 qoffset &= ~(AAC_QUEUE_ALIGN - 1);
1587 sc->aac_queues =
1588 (struct aac_queue_table *)((uintptr_t)sc->aac_common + qoffset);
1589 ip->CommHeaderAddress = sc->aac_common_busaddr + qoffset;
1590
1591 sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1592 AAC_HOST_NORM_CMD_ENTRIES;
1593 sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1594 AAC_HOST_NORM_CMD_ENTRIES;
1595 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1596 AAC_HOST_HIGH_CMD_ENTRIES;
1597 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1598 AAC_HOST_HIGH_CMD_ENTRIES;
1599 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1600 AAC_ADAP_NORM_CMD_ENTRIES;
1601 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1602 AAC_ADAP_NORM_CMD_ENTRIES;
1603 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1604 AAC_ADAP_HIGH_CMD_ENTRIES;
1605 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1606 AAC_ADAP_HIGH_CMD_ENTRIES;
1607 sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1608 AAC_HOST_NORM_RESP_ENTRIES;
1609 sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1610 AAC_HOST_NORM_RESP_ENTRIES;
1611 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1612 AAC_HOST_HIGH_RESP_ENTRIES;
1613 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1614 AAC_HOST_HIGH_RESP_ENTRIES;
1615 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1616 AAC_ADAP_NORM_RESP_ENTRIES;
1617 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1618 AAC_ADAP_NORM_RESP_ENTRIES;
1619 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1620 AAC_ADAP_HIGH_RESP_ENTRIES;
1621 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1622 AAC_ADAP_HIGH_RESP_ENTRIES;
1623 sc->aac_qentries[AAC_HOST_NORM_CMD_QUEUE] =
1624 &sc->aac_queues->qt_HostNormCmdQueue[0];
1625 sc->aac_qentries[AAC_HOST_HIGH_CMD_QUEUE] =
1626 &sc->aac_queues->qt_HostHighCmdQueue[0];
1627 sc->aac_qentries[AAC_ADAP_NORM_CMD_QUEUE] =
1628 &sc->aac_queues->qt_AdapNormCmdQueue[0];
1629 sc->aac_qentries[AAC_ADAP_HIGH_CMD_QUEUE] =
1630 &sc->aac_queues->qt_AdapHighCmdQueue[0];
1631 sc->aac_qentries[AAC_HOST_NORM_RESP_QUEUE] =
1632 &sc->aac_queues->qt_HostNormRespQueue[0];
1633 sc->aac_qentries[AAC_HOST_HIGH_RESP_QUEUE] =
1634 &sc->aac_queues->qt_HostHighRespQueue[0];
1635 sc->aac_qentries[AAC_ADAP_NORM_RESP_QUEUE] =
1636 &sc->aac_queues->qt_AdapNormRespQueue[0];
1637 sc->aac_qentries[AAC_ADAP_HIGH_RESP_QUEUE] =
1638 &sc->aac_queues->qt_AdapHighRespQueue[0];
1639
1640 /*
1641 * Do controller-type-specific initialisation
1642 */
1643 switch (sc->aac_hwif) {
1644 case AAC_HWIF_I960RX:
1645 AAC_SETREG4(sc, AAC_RX_ODBR, ~0);
1646 break;
1647 }
1648
1649 /*
1650 * Give the init structure to the controller.
1651 */
1652 if (aac_sync_command(sc, AAC_MONKER_INITSTRUCT,
1653 sc->aac_common_busaddr +
1654 offsetof(struct aac_common, ac_init), 0, 0, 0,
1655 NULL)) {
1656 device_printf(sc->aac_dev,
1657 "error establishing init structure\n");
1658 error = EIO;
1659 goto out;
1660 }
1661
1662 error = 0;
1663out:
1664 return(error);
1665}
1666
1667/*
1668 * Send a synchronous command to the controller and wait for a result.
1669 */
1670static int
1671aac_sync_command(struct aac_softc *sc, u_int32_t command,
1672 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3,
1673 u_int32_t *sp)
1674{
1675 time_t then;
1676 u_int32_t status;
1677
1678 debug_called(3);
1679
1680 /* populate the mailbox */
1681 AAC_SET_MAILBOX(sc, command, arg0, arg1, arg2, arg3);
1682
1683 /* ensure the sync command doorbell flag is cleared */
1684 AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND);
1685
1686 /* then set it to signal the adapter */
1687 AAC_QNOTIFY(sc, AAC_DB_SYNC_COMMAND);
1688
1689 /* spin waiting for the command to complete */
1690 then = time_second;
1691 do {
1692 if (time_second > (then + AAC_IMMEDIATE_TIMEOUT)) {
1693 debug(1, "timed out");
1694 return(EIO);
1695 }
1696 } while (!(AAC_GET_ISTATUS(sc) & AAC_DB_SYNC_COMMAND));
1697
1698 /* clear the completion flag */
1699 AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND);
1700
1701 /* get the command status */
1702 status = AAC_GET_MAILBOX(sc, 0);
1703 if (sp != NULL)
1704 *sp = status;
1705 return(0);
1706}
1707
1708/*
1709 * Grab the sync fib area.
1710 */
1711int
1712aac_alloc_sync_fib(struct aac_softc *sc, struct aac_fib **fib, int flags)
1713{
1714
1715 /*
1716 * If the force flag is set, the system is shutting down, or in
1717 * trouble. Ignore the mutex.
1718 */
1719 if (!(flags & AAC_SYNC_LOCK_FORCE))
1720 AAC_LOCK_ACQUIRE(&sc->aac_sync_lock);
1721
1722 *fib = &sc->aac_common->ac_sync_fib;
1723
1724 return (1);
1725}
1726
1727/*
1728 * Release the sync fib area.
1729 */
1730void
1731aac_release_sync_fib(struct aac_softc *sc)
1732{
1733
1734 AAC_LOCK_RELEASE(&sc->aac_sync_lock);
1735}
1736
1737/*
1738 * Send a synchronous FIB to the controller and wait for a result.
1739 */
1740int
1741aac_sync_fib(struct aac_softc *sc, u_int32_t command, u_int32_t xferstate,
1742 struct aac_fib *fib, u_int16_t datasize)
1743{
1744 debug_called(3);
1745
1746 if (datasize > AAC_FIB_DATASIZE)
1747 return(EINVAL);
1748
1749 /*
1750 * Set up the sync FIB
1751 */
1752 fib->Header.XferState = AAC_FIBSTATE_HOSTOWNED |
1753 AAC_FIBSTATE_INITIALISED |
1754 AAC_FIBSTATE_EMPTY;
1755 fib->Header.XferState |= xferstate;
1756 fib->Header.Command = command;
1757 fib->Header.StructType = AAC_FIBTYPE_TFIB;
1758 fib->Header.Size = sizeof(struct aac_fib) + datasize;
1759 fib->Header.SenderSize = sizeof(struct aac_fib);
1760 fib->Header.SenderFibAddress = 0; /* Not needed */
1761 fib->Header.ReceiverFibAddress = sc->aac_common_busaddr +
1762 offsetof(struct aac_common,
1763 ac_sync_fib);
1764
1765 /*
1766 * Give the FIB to the controller, wait for a response.
1767 */
1768 if (aac_sync_command(sc, AAC_MONKER_SYNCFIB,
1769 fib->Header.ReceiverFibAddress, 0, 0, 0, NULL)) {
1770 debug(2, "IO error");
1771 return(EIO);
1772 }
1773
1774 return (0);
1775}
1776
1777/*
1778 * Adapter-space FIB queue manipulation
1779 *
1780 * Note that the queue implementation here is a little funky; neither the PI or
1781 * CI will ever be zero. This behaviour is a controller feature.
1782 */
1783static struct {
1784 int size;
1785 int notify;
1786} aac_qinfo[] = {
1787 {AAC_HOST_NORM_CMD_ENTRIES, AAC_DB_COMMAND_NOT_FULL},
1788 {AAC_HOST_HIGH_CMD_ENTRIES, 0},
1789 {AAC_ADAP_NORM_CMD_ENTRIES, AAC_DB_COMMAND_READY},
1790 {AAC_ADAP_HIGH_CMD_ENTRIES, 0},
1791 {AAC_HOST_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_NOT_FULL},
1792 {AAC_HOST_HIGH_RESP_ENTRIES, 0},
1793 {AAC_ADAP_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_READY},
1794 {AAC_ADAP_HIGH_RESP_ENTRIES, 0}
1795};
1796
1797/*
1798 * Atomically insert an entry into the nominated queue, returns 0 on success or
1799 * EBUSY if the queue is full.
1800 *
1801 * Note: it would be more efficient to defer notifying the controller in
1802 * the case where we may be inserting several entries in rapid succession,
1803 * but implementing this usefully may be difficult (it would involve a
1804 * separate queue/notify interface).
1805 */
1806static int
1807aac_enqueue_fib(struct aac_softc *sc, int queue, struct aac_command *cm)
1808{
1809 u_int32_t pi, ci;
1810 int error;
1811 u_int32_t fib_size;
1812 u_int32_t fib_addr;
1813
1814 debug_called(3);
1815
1816 fib_size = cm->cm_fib->Header.Size;
1817 fib_addr = cm->cm_fib->Header.ReceiverFibAddress;
1818
1819 /* get the producer/consumer indices */
1820 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
1821 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
1822
1823 /* wrap the queue? */
1824 if (pi >= aac_qinfo[queue].size)
1825 pi = 0;
1826
1827 /* check for queue full */
1828 if ((pi + 1) == ci) {
1829 error = EBUSY;
1830 goto out;
1831 }
1832
1833 /* populate queue entry */
1834 (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size;
1835 (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr;
1836
1837 /* update producer index */
1838 sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;
1839
1840 /*
1841 * To avoid a race with its completion interrupt, place this command on
1842 * the busy queue prior to advertising it to the controller.
1843 */
1844 aac_enqueue_busy(cm);
1845
1846 /* notify the adapter if we know how */
1847 if (aac_qinfo[queue].notify != 0)
1848 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
1849
1850 error = 0;
1851
1852out:
1853 return(error);
1854}
1855
1856/*
1857 * Atomically remove one entry from the nominated queue, returns 0 on
1858 * success or ENOENT if the queue is empty.
1859 */
1860static int
1861aac_dequeue_fib(struct aac_softc *sc, int queue, u_int32_t *fib_size,
1862 struct aac_fib **fib_addr)
1863{
1864 u_int32_t pi, ci;
1865 u_int32_t fib_index;
1866 int error;
1867 int notify;
1868
1869 debug_called(3);
1870
1871 /* get the producer/consumer indices */
1872 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
1873 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
1874
1875 /* check for queue empty */
1876 if (ci == pi) {
1877 error = ENOENT;
1878 goto out;
1879 }
1880
1881 /* wrap the pi so the following test works */
1882 if (pi >= aac_qinfo[queue].size)
1883 pi = 0;
1884
1885 notify = 0;
1886 if (ci == pi + 1)
1887 notify++;
1888
1889 /* wrap the queue? */
1890 if (ci >= aac_qinfo[queue].size)
1891 ci = 0;
1892
1893 /* fetch the entry */
1894 *fib_size = (sc->aac_qentries[queue] + ci)->aq_fib_size;
1895
1896 switch (queue) {
1897 case AAC_HOST_NORM_CMD_QUEUE:
1898 case AAC_HOST_HIGH_CMD_QUEUE:
1899 /*
1900 * The aq_fib_addr is only 32 bits wide so it can't be counted
1901 * on to hold an address. For AIF's, the adapter assumes
1902 * that it's giving us an address into the array of AIF fibs.
1903 * Therefore, we have to convert it to an index.
1904 */
1905 fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr /
1906 sizeof(struct aac_fib);
1907 *fib_addr = &sc->aac_common->ac_fibs[fib_index];
1908 break;
1909
1910 case AAC_HOST_NORM_RESP_QUEUE:
1911 case AAC_HOST_HIGH_RESP_QUEUE:
1912 {
1913 struct aac_command *cm;
1914
1915 /*
1916 * As above, an index is used instead of an actual address.
1917 * Gotta shift the index to account for the fast response
1918 * bit. No other correction is needed since this value was
1919 * originally provided by the driver via the SenderFibAddress
1920 * field.
1921 */
1922 fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr;
1923 cm = sc->aac_commands + (fib_index >> 1);
1924 *fib_addr = cm->cm_fib;
1925
1926 /*
1927 * Is this a fast response? If it is, update the fib fields in
1928 * local memory since the whole fib isn't DMA'd back up.
1929 */
1930 if (fib_index & 0x01) {
1931 (*fib_addr)->Header.XferState |= AAC_FIBSTATE_DONEADAP;
1932 *((u_int32_t*)((*fib_addr)->data)) = AAC_ERROR_NORMAL;
1933 }
1934 break;
1935 }
1936 default:
1937 panic("Invalid queue in aac_dequeue_fib()");
1938 break;
1939 }
1940
1941 /* update consumer index */
1942 sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX] = ci + 1;
1943
1944 /* if we have made the queue un-full, notify the adapter */
1945 if (notify && (aac_qinfo[queue].notify != 0))
1946 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
1947 error = 0;
1948
1949out:
1950 return(error);
1951}
1952
1953/*
1954 * Put our response to an Adapter Initialed Fib on the response queue
1955 */
1956static int
1957aac_enqueue_response(struct aac_softc *sc, int queue, struct aac_fib *fib)
1958{
1959 u_int32_t pi, ci;
1960 int error;
1961 u_int32_t fib_size;
1962 u_int32_t fib_addr;
1963
1964 debug_called(1);
1965
1966 /* Tell the adapter where the FIB is */
1967 fib_size = fib->Header.Size;
1968 fib_addr = fib->Header.SenderFibAddress;
1969 fib->Header.ReceiverFibAddress = fib_addr;
1970
1971 /* get the producer/consumer indices */
1972 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
1973 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
1974
1975 /* wrap the queue? */
1976 if (pi >= aac_qinfo[queue].size)
1977 pi = 0;
1978
1979 /* check for queue full */
1980 if ((pi + 1) == ci) {
1981 error = EBUSY;
1982 goto out;
1983 }
1984
1985 /* populate queue entry */
1986 (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size;
1987 (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr;
1988
1989 /* update producer index */
1990 sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;
1991
1992 /* notify the adapter if we know how */
1993 if (aac_qinfo[queue].notify != 0)
1994 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
1995
1996 error = 0;
1997
1998out:
1999 return(error);
2000}
2001
2002/*
2003 * Check for commands that have been outstanding for a suspiciously long time,
2004 * and complain about them.
2005 */
2006static void
2007aac_timeout(struct aac_softc *sc)
2008{
2009 struct aac_command *cm;
2010 time_t deadline;
2011
2012 /*
2013 * Traverse the busy command list, bitch about late commands once
2014 * only.
2015 */
2016 deadline = time_second - AAC_CMD_TIMEOUT;
2017 TAILQ_FOREACH(cm, &sc->aac_busy, cm_link) {
2018 if ((cm->cm_timestamp < deadline)
2019 /* && !(cm->cm_flags & AAC_CMD_TIMEDOUT) */) {
2020 cm->cm_flags |= AAC_CMD_TIMEDOUT;
2021 device_printf(sc->aac_dev,
2022 "COMMAND %p TIMEOUT AFTER %d SECONDS\n",
2023 cm, (int)(time_second-cm->cm_timestamp));
2024 AAC_PRINT_FIB(sc, cm->cm_fib);
2025 }
2026 }
2027
2028 return;
2029}
2030
2031/*
2032 * Interface Function Vectors
2033 */
2034
2035/*
2036 * Read the current firmware status word.
2037 */
2038static int
2039aac_sa_get_fwstatus(struct aac_softc *sc)
2040{
2041 debug_called(3);
2042
2043 return(AAC_GETREG4(sc, AAC_SA_FWSTATUS));
2044}
2045
2046static int
2047aac_rx_get_fwstatus(struct aac_softc *sc)
2048{
2049 debug_called(3);
2050
2051 return(AAC_GETREG4(sc, AAC_RX_FWSTATUS));
2052}
2053
2054static int
2055aac_fa_get_fwstatus(struct aac_softc *sc)
2056{
2057 int val;
2058
2059 debug_called(3);
2060
2061 val = AAC_GETREG4(sc, AAC_FA_FWSTATUS);
2062 return (val);
2063}
2064
2065/*
2066 * Notify the controller of a change in a given queue
2067 */
2068
2069static void
2070aac_sa_qnotify(struct aac_softc *sc, int qbit)
2071{
2072 debug_called(3);
2073
2074 AAC_SETREG2(sc, AAC_SA_DOORBELL1_SET, qbit);
2075}
2076
2077static void
2078aac_rx_qnotify(struct aac_softc *sc, int qbit)
2079{
2080 debug_called(3);
2081
2082 AAC_SETREG4(sc, AAC_RX_IDBR, qbit);
2083}
2084
2085static void
2086aac_fa_qnotify(struct aac_softc *sc, int qbit)
2087{
2088 debug_called(3);
2089
2090 AAC_SETREG2(sc, AAC_FA_DOORBELL1, qbit);
2091 AAC_FA_HACK(sc);
2092}
2093
2094/*
2095 * Get the interrupt reason bits
2096 */
2097static int
2098aac_sa_get_istatus(struct aac_softc *sc)
2099{
2100 debug_called(3);
2101
2102 return(AAC_GETREG2(sc, AAC_SA_DOORBELL0));
2103}
2104
2105static int
2106aac_rx_get_istatus(struct aac_softc *sc)
2107{
2108 debug_called(3);
2109
2110 return(AAC_GETREG4(sc, AAC_RX_ODBR));
2111}
2112
2113static int
2114aac_fa_get_istatus(struct aac_softc *sc)
2115{
2116 int val;
2117
2118 debug_called(3);
2119
2120 val = AAC_GETREG2(sc, AAC_FA_DOORBELL0);
2121 return (val);
2122}
2123
2124/*
2125 * Clear some interrupt reason bits
2126 */
2127static void
2128aac_sa_clear_istatus(struct aac_softc *sc, int mask)
2129{
2130 debug_called(3);
2131
2132 AAC_SETREG2(sc, AAC_SA_DOORBELL0_CLEAR, mask);
2133}
2134
2135static void
2136aac_rx_clear_istatus(struct aac_softc *sc, int mask)
2137{
2138 debug_called(3);
2139
2140 AAC_SETREG4(sc, AAC_RX_ODBR, mask);
2141}
2142
2143static void
2144aac_fa_clear_istatus(struct aac_softc *sc, int mask)
2145{
2146 debug_called(3);
2147
2148 AAC_SETREG2(sc, AAC_FA_DOORBELL0_CLEAR, mask);
2149 AAC_FA_HACK(sc);
2150}
2151
2152/*
2153 * Populate the mailbox and set the command word
2154 */
2155static void
2156aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command,
2157 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2158{
2159 debug_called(4);
2160
2161 AAC_SETREG4(sc, AAC_SA_MAILBOX, command);
2162 AAC_SETREG4(sc, AAC_SA_MAILBOX + 4, arg0);
2163 AAC_SETREG4(sc, AAC_SA_MAILBOX + 8, arg1);
2164 AAC_SETREG4(sc, AAC_SA_MAILBOX + 12, arg2);
2165 AAC_SETREG4(sc, AAC_SA_MAILBOX + 16, arg3);
2166}
2167
2168static void
2169aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command,
2170 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2171{
2172 debug_called(4);
2173
2174 AAC_SETREG4(sc, AAC_RX_MAILBOX, command);
2175 AAC_SETREG4(sc, AAC_RX_MAILBOX + 4, arg0);
2176 AAC_SETREG4(sc, AAC_RX_MAILBOX + 8, arg1);
2177 AAC_SETREG4(sc, AAC_RX_MAILBOX + 12, arg2);
2178 AAC_SETREG4(sc, AAC_RX_MAILBOX + 16, arg3);
2179}
2180
2181static void
2182aac_fa_set_mailbox(struct aac_softc *sc, u_int32_t command,
2183 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2184{
2185 debug_called(4);
2186
2187 AAC_SETREG4(sc, AAC_FA_MAILBOX, command);
2188 AAC_FA_HACK(sc);
2189 AAC_SETREG4(sc, AAC_FA_MAILBOX + 4, arg0);
2190 AAC_FA_HACK(sc);
2191 AAC_SETREG4(sc, AAC_FA_MAILBOX + 8, arg1);
2192 AAC_FA_HACK(sc);
2193 AAC_SETREG4(sc, AAC_FA_MAILBOX + 12, arg2);
2194 AAC_FA_HACK(sc);
2195 AAC_SETREG4(sc, AAC_FA_MAILBOX + 16, arg3);
2196 AAC_FA_HACK(sc);
2197}
2198
2199/*
2200 * Fetch the immediate command status word
2201 */
2202static int
2203aac_sa_get_mailbox(struct aac_softc *sc, int mb)
2204{
2205 debug_called(4);
2206
2207 return(AAC_GETREG4(sc, AAC_SA_MAILBOX + (mb * 4)));
2208}
2209
2210static int
2211aac_rx_get_mailbox(struct aac_softc *sc, int mb)
2212{
2213 debug_called(4);
2214
2215 return(AAC_GETREG4(sc, AAC_RX_MAILBOX + (mb * 4)));
2216}
2217
2218static int
2219aac_fa_get_mailbox(struct aac_softc *sc, int mb)
2220{
2221 int val;
2222
2223 debug_called(4);
2224
2225 val = AAC_GETREG4(sc, AAC_FA_MAILBOX + (mb * 4));
2226 return (val);
2227}
2228
2229/*
2230 * Set/clear interrupt masks
2231 */
2232static void
2233aac_sa_set_interrupts(struct aac_softc *sc, int enable)
2234{
2235 debug(2, "%sable interrupts", enable ? "en" : "dis");
2236
2237 if (enable) {
2238 AAC_SETREG2((sc), AAC_SA_MASK0_CLEAR, AAC_DB_INTERRUPTS);
2239 } else {
2240 AAC_SETREG2((sc), AAC_SA_MASK0_SET, ~0);
2241 }
2242}
2243
2244static void
2245aac_rx_set_interrupts(struct aac_softc *sc, int enable)
2246{
2247 debug(2, "%sable interrupts", enable ? "en" : "dis");
2248
2249 if (enable) {
2250 AAC_SETREG4(sc, AAC_RX_OIMR, ~AAC_DB_INTERRUPTS);
2251 } else {
2252 AAC_SETREG4(sc, AAC_RX_OIMR, ~0);
2253 }
2254}
2255
2256static void
2257aac_fa_set_interrupts(struct aac_softc *sc, int enable)
2258{
2259 debug(2, "%sable interrupts", enable ? "en" : "dis");
2260
2261 if (enable) {
2262 AAC_SETREG2((sc), AAC_FA_MASK0_CLEAR, AAC_DB_INTERRUPTS);
2263 AAC_FA_HACK(sc);
2264 } else {
2265 AAC_SETREG2((sc), AAC_FA_MASK0, ~0);
2266 AAC_FA_HACK(sc);
2267 }
2268}
2269
2270/*
2271 * Debugging and Diagnostics
2272 */
2273
2274/*
2275 * Print some information about the controller.
2276 */
2277static void
2278aac_describe_controller(struct aac_softc *sc)
2279{
2280 struct aac_fib *fib;
2281 struct aac_adapter_info *info;
2282
2283 debug_called(2);
2284
2285 aac_alloc_sync_fib(sc, &fib, 0);
2286
2287 fib->data[0] = 0;
2288 if (aac_sync_fib(sc, RequestAdapterInfo, 0, fib, 1)) {
2289 device_printf(sc->aac_dev, "RequestAdapterInfo failed\n");
2290 aac_release_sync_fib(sc);
2291 return;
2292 }
2293 info = (struct aac_adapter_info *)&fib->data[0];
2294
2295 device_printf(sc->aac_dev, "%s %dMHz, %dMB cache memory, %s\n",
2296 aac_describe_code(aac_cpu_variant, info->CpuVariant),
2297 info->ClockSpeed, info->BufferMem / (1024 * 1024),
2298 aac_describe_code(aac_battery_platform,
2299 info->batteryPlatform));
2300
2301 /* save the kernel revision structure for later use */
2302 sc->aac_revision = info->KernelRevision;
2303 device_printf(sc->aac_dev, "Kernel %d.%d-%d, Build %d, S/N %6X\n",
2304 info->KernelRevision.external.comp.major,
2305 info->KernelRevision.external.comp.minor,
2306 info->KernelRevision.external.comp.dash,
2307 info->KernelRevision.buildNumber,
2308 (u_int32_t)(info->SerialNumber & 0xffffff));
2309
2310 aac_release_sync_fib(sc);
2311
2312 if (1 || bootverbose) {
2313 device_printf(sc->aac_dev, "Supported Options=%b\n",
2314 sc->supported_options,
2315 "\20"
2316 "\1SNAPSHOT"
2317 "\2CLUSTERS"
2318 "\3WCACHE"
2319 "\4DATA64"
2320 "\5HOSTTIME"
2321 "\6RAID50"
2322 "\7WINDOW4GB"
2323 "\10SCSIUPGD"
2324 "\11SOFTERR"
2325 "\12NORECOND"
2326 "\13SGMAP64"
2327 "\14ALARM"
2328 "\15NONDASD");
2329 }
2330}
2331
2332/*
2333 * Look up a text description of a numeric error code and return a pointer to
2334 * same.
2335 */
2336static char *
2337aac_describe_code(struct aac_code_lookup *table, u_int32_t code)
2338{
2339 int i;
2340
2341 for (i = 0; table[i].string != NULL; i++)
2342 if (table[i].code == code)
2343 return(table[i].string);
2344 return(table[i + 1].string);
2345}
2346
2347/*
2348 * Management Interface
2349 */
2350
2351static int
2352aac_open(dev_t dev, int flags, int fmt, d_thread_t *td)
2353{
2354 struct aac_softc *sc;
2355
2356 debug_called(2);
2357
2358 sc = dev->si_drv1;
2359
2360 /* Check to make sure the device isn't already open */
2361 if (sc->aac_state & AAC_STATE_OPEN) {
2362 return EBUSY;
2363 }
2364 sc->aac_state |= AAC_STATE_OPEN;
2365
2366 return 0;
2367}
2368
2369static int
2370aac_close(dev_t dev, int flags, int fmt, d_thread_t *td)
2371{
2372 struct aac_softc *sc;
2373
2374 debug_called(2);
2375
2376 sc = dev->si_drv1;
2377
2378 /* Mark this unit as no longer open */
2379 sc->aac_state &= ~AAC_STATE_OPEN;
2380
2381 return 0;
2382}
2383
2384static int
2385aac_ioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, d_thread_t *td)
2386{
2387 union aac_statrequest *as;
2388 struct aac_softc *sc;
2389 int error = 0;
2390 uint32_t cookie;
2391
2392 debug_called(2);
2393
2394 as = (union aac_statrequest *)arg;
2395 sc = dev->si_drv1;
2396
2397 switch (cmd) {
2398 case AACIO_STATS:
2399 switch (as->as_item) {
2400 case AACQ_FREE:
2401 case AACQ_BIO:
2402 case AACQ_READY:
2403 case AACQ_BUSY:
2404 bcopy(&sc->aac_qstat[as->as_item], &as->as_qstat,
2405 sizeof(struct aac_qstat));
2406 break;
2407 default:
2408 error = ENOENT;
2409 break;
2410 }
2411 break;
2412
2413 case FSACTL_SENDFIB:
2414 arg = *(caddr_t*)arg;
2415 case FSACTL_LNX_SENDFIB:
2416 debug(1, "FSACTL_SENDFIB");
2417 error = aac_ioctl_sendfib(sc, arg);
2418 break;
2419 case FSACTL_AIF_THREAD:
2420 case FSACTL_LNX_AIF_THREAD:
2421 debug(1, "FSACTL_AIF_THREAD");
2422 error = EINVAL;
2423 break;
2424 case FSACTL_OPEN_GET_ADAPTER_FIB:
2425 arg = *(caddr_t*)arg;
2426 case FSACTL_LNX_OPEN_GET_ADAPTER_FIB:
2427 debug(1, "FSACTL_OPEN_GET_ADAPTER_FIB");
2428 /*
2429 * Pass the caller out an AdapterFibContext.
2430 *
2431 * Note that because we only support one opener, we
2432 * basically ignore this. Set the caller's context to a magic
2433 * number just in case.
2434 *
2435 * The Linux code hands the driver a pointer into kernel space,
2436 * and then trusts it when the caller hands it back. Aiee!
2437 * Here, we give it the proc pointer of the per-adapter aif
2438 * thread. It's only used as a sanity check in other calls.
2439 */
2440 cookie = (uint32_t)(uintptr_t)sc->aifthread;
2441 error = copyout(&cookie, arg, sizeof(cookie));
2442 break;
2443 case FSACTL_GET_NEXT_ADAPTER_FIB:
2444 arg = *(caddr_t*)arg;
2445 case FSACTL_LNX_GET_NEXT_ADAPTER_FIB:
2446 debug(1, "FSACTL_GET_NEXT_ADAPTER_FIB");
2447 error = aac_getnext_aif(sc, arg);
2448 break;
2449 case FSACTL_CLOSE_GET_ADAPTER_FIB:
2450 case FSACTL_LNX_CLOSE_GET_ADAPTER_FIB:
2451 debug(1, "FSACTL_CLOSE_GET_ADAPTER_FIB");
2452 /* don't do anything here */
2453 break;
2454 case FSACTL_MINIPORT_REV_CHECK:
2455 arg = *(caddr_t*)arg;
2456 case FSACTL_LNX_MINIPORT_REV_CHECK:
2457 debug(1, "FSACTL_MINIPORT_REV_CHECK");
2458 error = aac_rev_check(sc, arg);
2459 break;
2460 case FSACTL_QUERY_DISK:
2461 arg = *(caddr_t*)arg;
2462 case FSACTL_LNX_QUERY_DISK:
2463 debug(1, "FSACTL_QUERY_DISK");
2464 error = aac_query_disk(sc, arg);
2465 break;
2466 case FSACTL_DELETE_DISK:
2467 case FSACTL_LNX_DELETE_DISK:
2468 /*
2469 * We don't trust the underland to tell us when to delete a
2470 * container, rather we rely on an AIF coming from the
2471 * controller
2472 */
2473 error = 0;
2474 break;
2475 default:
2476 debug(1, "unsupported cmd 0x%lx\n", cmd);
2477 error = EINVAL;
2478 break;
2479 }
2480 return(error);
2481}
2482
2483static int
2484aac_poll(dev_t dev, int poll_events, d_thread_t *td)
2485{
2486 struct aac_softc *sc;
2487 int revents;
2488
2489 sc = dev->si_drv1;
2490 revents = 0;
2491
2492 AAC_LOCK_ACQUIRE(&sc->aac_aifq_lock);
2493 if ((poll_events & (POLLRDNORM | POLLIN)) != 0) {
2494 if (sc->aac_aifq_tail != sc->aac_aifq_head)
2495 revents |= poll_events & (POLLIN | POLLRDNORM);
2496 }
2497 AAC_LOCK_RELEASE(&sc->aac_aifq_lock);
2498
2499 if (revents == 0) {
2500 if (poll_events & (POLLIN | POLLRDNORM))
2501 selrecord(td, &sc->rcv_select);
2502 }
2503
2504 return (revents);
2505}
2506
2507/*
2508 * Send a FIB supplied from userspace
2509 */
2510static int
2511aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib)
2512{
2513 struct aac_command *cm;
2514 int size, error;
2515
2516 debug_called(2);
2517
2518 cm = NULL;
2519
2520 /*
2521 * Get a command
2522 */
2523 AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
2524 if (aac_alloc_command(sc, &cm)) {
2525 error = EBUSY;
2526 goto out;
2527 }
2528
2529 /*
2530 * Fetch the FIB header, then re-copy to get data as well.
2531 */
2532 if ((error = copyin(ufib, cm->cm_fib,
2533 sizeof(struct aac_fib_header))) != 0)
2534 goto out;
2535 size = cm->cm_fib->Header.Size + sizeof(struct aac_fib_header);
2536 if (size > sizeof(struct aac_fib)) {
2537 device_printf(sc->aac_dev, "incoming FIB oversized (%d > %zd)\n",
2538 size, sizeof(struct aac_fib));
2539 size = sizeof(struct aac_fib);
2540 }
2541 if ((error = copyin(ufib, cm->cm_fib, size)) != 0)
2542 goto out;
2543 cm->cm_fib->Header.Size = size;
2544 cm->cm_timestamp = time_second;
2545
2546 /*
2547 * Pass the FIB to the controller, wait for it to complete.
2548 */
2549 if ((error = aac_wait_command(cm, 30)) != 0) { /* XXX user timeout? */
2550 device_printf(sc->aac_dev,
2551 "aac_wait_command return %d\n", error);
2552 goto out;
2553 }
2554
2555 /*
2556 * Copy the FIB and data back out to the caller.
2557 */
2558 size = cm->cm_fib->Header.Size;
2559 if (size > sizeof(struct aac_fib)) {
2560 device_printf(sc->aac_dev, "outbound FIB oversized (%d > %zd)\n",
2561 size, sizeof(struct aac_fib));
2562 size = sizeof(struct aac_fib);
2563 }
2564 error = copyout(cm->cm_fib, ufib, size);
2565
2566out:
2567 if (cm != NULL) {
2568 aac_release_command(cm);
2569 }
2570
2571 AAC_LOCK_RELEASE(&sc->aac_io_lock);
2572 return(error);
2573}
2574
2575/*
2576 * Handle an AIF sent to us by the controller; queue it for later reference.
2577 * If the queue fills up, then drop the older entries.
2578 */
2579static void
2580aac_handle_aif(struct aac_softc *sc, struct aac_fib *fib)
2581{
2582 struct aac_aif_command *aif;
2583 struct aac_container *co, *co_next;
2584 struct aac_mntinfo *mi;
2585 struct aac_mntinforesp *mir = NULL;
2586 u_int16_t rsize;
2587 int next, found;
2588 int count = 0, added = 0, i = 0;
2589
2590 debug_called(2);
2591
2592 aif = (struct aac_aif_command*)&fib->data[0];
2593 aac_print_aif(sc, aif);
2594
2595 /* Is it an event that we should care about? */
2596 switch (aif->command) {
2597 case AifCmdEventNotify:
2598 switch (aif->data.EN.type) {
2599 case AifEnAddContainer:
2600 case AifEnDeleteContainer:
2601 /*
2602 * A container was added or deleted, but the message
2603 * doesn't tell us anything else! Re-enumerate the
2604 * containers and sort things out.
2605 */
2606 aac_alloc_sync_fib(sc, &fib, 0);
2607 mi = (struct aac_mntinfo *)&fib->data[0];
2608 do {
2609 /*
2610 * Ask the controller for its containers one at
2611 * a time.
2612 * XXX What if the controller's list changes
2613 * midway through this enumaration?
2614 * XXX This should be done async.
2615 */
2616 bzero(mi, sizeof(struct aac_mntinfo));
2617 mi->Command = VM_NameServe;
2618 mi->MntType = FT_FILESYS;
2619 mi->MntCount = i;
2620 rsize = sizeof(mir);
2621 if (aac_sync_fib(sc, ContainerCommand, 0, fib,
2622 sizeof(struct aac_mntinfo))) {
2623 printf("Error probing container %d\n",
2624 i);
2625 continue;
2626 }
2627 mir = (struct aac_mntinforesp *)&fib->data[0];
2628 /* XXX Need to check if count changed */
2629 count = mir->MntRespCount;
2630 /*
2631 * Check the container against our list.
2632 * co->co_found was already set to 0 in a
2633 * previous run.
2634 */
2635 if ((mir->Status == ST_OK) &&
2636 (mir->MntTable[0].VolType != CT_NONE)) {
2637 found = 0;
2638 TAILQ_FOREACH(co,
2639 &sc->aac_container_tqh,
2640 co_link) {
2641 if (co->co_mntobj.ObjectId ==
2642 mir->MntTable[0].ObjectId) {
2643 co->co_found = 1;
2644 found = 1;
2645 break;
2646 }
2647 }
2648 /*
2649 * If the container matched, continue
2650 * in the list.
2651 */
2652 if (found) {
2653 i++;
2654 continue;
2655 }
2656
2657 /*
2658 * This is a new container. Do all the
2659 * appropriate things to set it up.
2660 */
2661 aac_add_container(sc, mir, 1);
2662 added = 1;
2663 }
2664 i++;
2665 } while ((i < count) && (i < AAC_MAX_CONTAINERS));
2666 aac_release_sync_fib(sc);
2667
2668 /*
2669 * Go through our list of containers and see which ones
2670 * were not marked 'found'. Since the controller didn't
2671 * list them they must have been deleted. Do the
2672 * appropriate steps to destroy the device. Also reset
2673 * the co->co_found field.
2674 */
2675 co = TAILQ_FIRST(&sc->aac_container_tqh);
2676 while (co != NULL) {
2677 if (co->co_found == 0) {
2678 device_delete_child(sc->aac_dev,
2679 co->co_disk);
2680 co_next = TAILQ_NEXT(co, co_link);
2681 AAC_LOCK_ACQUIRE(&sc->
2682 aac_container_lock);
2683 TAILQ_REMOVE(&sc->aac_container_tqh, co,
2684 co_link);
2685 AAC_LOCK_RELEASE(&sc->
2686 aac_container_lock);
2687 FREE(co, M_AACBUF);
2688 co = co_next;
2689 } else {
2690 co->co_found = 0;
2691 co = TAILQ_NEXT(co, co_link);
2692 }
2693 }
2694
2695 /* Attach the newly created containers */
2696 if (added)
2697 bus_generic_attach(sc->aac_dev);
2698
2699 break;
2700
2701 default:
2702 break;
2703 }
2704
2705 default:
2706 break;
2707 }
2708
2709 /* Copy the AIF data to the AIF queue for ioctl retrieval */
2710 AAC_LOCK_ACQUIRE(&sc->aac_aifq_lock);
2711 next = (sc->aac_aifq_head + 1) % AAC_AIFQ_LENGTH;
2712 if (next != sc->aac_aifq_tail) {
2713 bcopy(aif, &sc->aac_aifq[next], sizeof(struct aac_aif_command));
2714 sc->aac_aifq_head = next;
2715
2716 /* On the off chance that someone is sleeping for an aif... */
2717 if (sc->aac_state & AAC_STATE_AIF_SLEEPER)
2718 wakeup(sc->aac_aifq);
2719 /* Wakeup any poll()ers */
2720 selwakeuppri(&sc->rcv_select, PRIBIO);
2721 }
2722 AAC_LOCK_RELEASE(&sc->aac_aifq_lock);
2723
2724 return;
2725}
2726
2727/*
2728 * Return the Revision of the driver to userspace and check to see if the
2729 * userspace app is possibly compatible. This is extremely bogus since
2730 * our driver doesn't follow Adaptec's versioning system. Cheat by just
2731 * returning what the card reported.
2732 */
2733static int
2734aac_rev_check(struct aac_softc *sc, caddr_t udata)
2735{
2736 struct aac_rev_check rev_check;
2737 struct aac_rev_check_resp rev_check_resp;
2738 int error = 0;
2739
2740 debug_called(2);
2741
2742 /*
2743 * Copyin the revision struct from userspace
2744 */
2745 if ((error = copyin(udata, (caddr_t)&rev_check,
2746 sizeof(struct aac_rev_check))) != 0) {
2747 return error;
2748 }
2749
2750 debug(2, "Userland revision= %d\n",
2751 rev_check.callingRevision.buildNumber);
2752
2753 /*
2754 * Doctor up the response struct.
2755 */
2756 rev_check_resp.possiblyCompatible = 1;
2757 rev_check_resp.adapterSWRevision.external.ul =
2758 sc->aac_revision.external.ul;
2759 rev_check_resp.adapterSWRevision.buildNumber =
2760 sc->aac_revision.buildNumber;
2761
2762 return(copyout((caddr_t)&rev_check_resp, udata,
2763 sizeof(struct aac_rev_check_resp)));
2764}
2765
2766/*
2767 * Pass the caller the next AIF in their queue
2768 */
2769static int
2770aac_getnext_aif(struct aac_softc *sc, caddr_t arg)
2771{
2772 struct get_adapter_fib_ioctl agf;
2773 int error;
2774
2775 debug_called(2);
2776
2777 if ((error = copyin(arg, &agf, sizeof(agf))) == 0) {
2778
2779 /*
2780 * Check the magic number that we gave the caller.
2781 */
2782 if (agf.AdapterFibContext != (int)(uintptr_t)sc->aifthread) {
2783 error = EFAULT;
2784 } else {
2785 error = aac_return_aif(sc, agf.AifFib);
2786 if ((error == EAGAIN) && (agf.Wait)) {
2787 sc->aac_state |= AAC_STATE_AIF_SLEEPER;
2788 while (error == EAGAIN) {
2789 error = tsleep(sc->aac_aifq, PRIBIO |
2790 PCATCH, "aacaif", 0);
2791 if (error == 0)
2792 error = aac_return_aif(sc,
2793 agf.AifFib);
2794 }
2795 sc->aac_state &= ~AAC_STATE_AIF_SLEEPER;
2796 }
2797 }
2798 }
2799 return(error);
2800}
2801
2802/*
2803 * Hand the next AIF off the top of the queue out to userspace.
2804 */
2805static int
2806aac_return_aif(struct aac_softc *sc, caddr_t uptr)
2807{
2808 int next, error;
2809
2810 debug_called(2);
2811
2812 AAC_LOCK_ACQUIRE(&sc->aac_aifq_lock);
2813 if (sc->aac_aifq_tail == sc->aac_aifq_head) {
2814 AAC_LOCK_RELEASE(&sc->aac_aifq_lock);
2815 return (EAGAIN);
2816 }
2817
2818 next = (sc->aac_aifq_tail + 1) % AAC_AIFQ_LENGTH;
2819 error = copyout(&sc->aac_aifq[next], uptr,
2820 sizeof(struct aac_aif_command));
2821 if (error)
2822 device_printf(sc->aac_dev,
2823 "aac_return_aif: copyout returned %d\n", error);
2824 else
2825 sc->aac_aifq_tail = next;
2826
2827 AAC_LOCK_RELEASE(&sc->aac_aifq_lock);
2828 return(error);
2829}
2830
2831/*
2832 * Give the userland some information about the container. The AAC arch
2833 * expects the driver to be a SCSI passthrough type driver, so it expects
2834 * the containers to have b:t:l numbers. Fake it.
2835 */
2836static int
2837aac_query_disk(struct aac_softc *sc, caddr_t uptr)
2838{
2839 struct aac_query_disk query_disk;
2840 struct aac_container *co;
2841 struct aac_disk *disk;
2842 int error, id;
2843
2844 debug_called(2);
2845
2846 disk = NULL;
2847
2848 error = copyin(uptr, (caddr_t)&query_disk,
2849 sizeof(struct aac_query_disk));
2850 if (error)
2851 return (error);
2852
2853 id = query_disk.ContainerNumber;
2854 if (id == -1)
2855 return (EINVAL);
2856
2857 AAC_LOCK_ACQUIRE(&sc->aac_container_lock);
2858 TAILQ_FOREACH(co, &sc->aac_container_tqh, co_link) {
2859 if (co->co_mntobj.ObjectId == id)
2860 break;
2861 }
2862
2863 if (co == NULL) {
2864 query_disk.Valid = 0;
2865 query_disk.Locked = 0;
2866 query_disk.Deleted = 1; /* XXX is this right? */
2867 } else {
2868 disk = device_get_softc(co->co_disk);
2869 query_disk.Valid = 1;
2870 query_disk.Locked =
2871 (disk->ad_flags & AAC_DISK_OPEN) ? 1 : 0;
2872 query_disk.Deleted = 0;
2873 query_disk.Bus = device_get_unit(sc->aac_dev);
2874 query_disk.Target = disk->unit;
2875 query_disk.Lun = 0;
2876 query_disk.UnMapped = 0;
2877 sprintf(&query_disk.diskDeviceName[0], "%s%d",
|