kernel: Add D_MPSAFE to the ops of mfi(4), mrsas(4) and twa(4).
[dragonfly.git] / sys / dev / raid / amr / amr.c
1 /*-
2  * Copyright (c) 1999,2000 Michael Smith
3  * Copyright (c) 2000 BSDi
4  * Copyright (c) 2005 Scott Long
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  */
28 /*-
29  * Copyright (c) 2002 Eric Moore
30  * Copyright (c) 2002, 2004 LSI Logic Corporation
31  * All rights reserved.
32  *
33  * Redistribution and use in source and binary forms, with or without
34  * modification, are permitted provided that the following conditions
35  * are met:
36  * 1. Redistributions of source code must retain the above copyright
37  *    notice, this list of conditions and the following disclaimer.
38  * 2. Redistributions in binary form must reproduce the above copyright
39  *    notice, this list of conditions and the following disclaimer in the
40  *    documentation and/or other materials provided with the distribution.
41  * 3. The party using or redistributing the source code and binary forms
42  *    agrees to the disclaimer below and the terms and conditions set forth
43  *    herein.
44  *
45  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
46  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
49  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
51  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
52  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
53  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
54  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
55  * SUCH DAMAGE.
56  *
57  * $FreeBSD: src/sys/dev/amr/amr.c,v 1.99 2012/08/31 09:42:46 scottl Exp $
58  */
59
60 /*
61  * Driver for the AMI MegaRaid family of controllers.
62  */
63
64 #include <sys/param.h>
65 #include <sys/systm.h>
66 #include <sys/malloc.h>
67 #include <sys/kernel.h>
68 #include <sys/proc.h>
69 #include <sys/sysctl.h>
70 #include <sys/sysmsg.h>
71
72 #include <sys/bio.h>
73 #include <sys/bus.h>
74 #include <sys/conf.h>
75 #include <sys/stat.h>
76
77 #include <machine/cpu.h>
78 #include <sys/rman.h>
79
80 #include <bus/pci/pcireg.h>
81 #include <bus/pci/pcivar.h>
82
83 #include <dev/raid/amr/amrio.h>
84 #include <dev/raid/amr/amrreg.h>
85 #include <dev/raid/amr/amrvar.h>
86 #define AMR_DEFINE_TABLES
87 #include <dev/raid/amr/amr_tables.h>
88
89 SYSCTL_NODE(_hw, OID_AUTO, amr, CTLFLAG_RD, 0, "AMR driver parameters");
90
91 static d_open_t         amr_open;
92 static d_close_t        amr_close;
93 static d_ioctl_t        amr_ioctl;
94
95 static struct dev_ops amr_ops = {
96         { "amr", 0, 0 },
97         .d_open =       amr_open,
98         .d_close =      amr_close,
99         .d_ioctl =      amr_ioctl,
100 };
101
102 int linux_no_adapter = 0;
103 /*
104  * Initialisation, bus interface.
105  */
106 static void     amr_startup(void *arg);
107
108 /*
109  * Command wrappers
110  */
111 static int      amr_query_controller(struct amr_softc *sc);
112 static void     *amr_enquiry(struct amr_softc *sc, size_t bufsize, 
113                              u_int8_t cmd, u_int8_t cmdsub, u_int8_t cmdqual, int *status);
114 static void     amr_completeio(struct amr_command *ac);
115 static int      amr_support_ext_cdb(struct amr_softc *sc);
116
117 /*
118  * Command buffer allocation.
119  */
120 static void     amr_alloccmd_cluster(struct amr_softc *sc);
121 static void     amr_freecmd_cluster(struct amr_command_cluster *acc);
122
123 /*
124  * Command processing.
125  */
126 static int      amr_bio_command(struct amr_softc *sc, struct amr_command **acp);
127 static int      amr_wait_command(struct amr_command *ac);
128 static int      amr_mapcmd(struct amr_command *ac);
129 static void     amr_unmapcmd(struct amr_command *ac);
130 static int      amr_start(struct amr_command *ac);
131 static void     amr_complete(void *context, ac_qhead_t *head);
132 static void     amr_setup_sg(void *arg, bus_dma_segment_t *segs, int nsegments, int error);
133 static void     amr_setup_data(void *arg, bus_dma_segment_t *segs, int nsegments, int error);
134 static void     amr_setup_ccb(void *arg, bus_dma_segment_t *segs, int nsegments, int error);
135 static void     amr_abort_load(struct amr_command *ac);
136
137 /*
138  * Interface-specific shims
139  */
140 static int      amr_quartz_submit_command(struct amr_command *ac);
141 static int      amr_quartz_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave);
142 static int      amr_quartz_poll_command(struct amr_command *ac);
143 static int      amr_quartz_poll_command1(struct amr_softc *sc, struct amr_command *ac);
144
145 static int      amr_std_submit_command(struct amr_command *ac);
146 static int      amr_std_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave);
147 static int      amr_std_poll_command(struct amr_command *ac);
148 static void     amr_std_attach_mailbox(struct amr_softc *sc);
149
150 #ifdef AMR_BOARD_INIT
151 static int      amr_quartz_init(struct amr_softc *sc);
152 static int      amr_std_init(struct amr_softc *sc);
153 #endif
154
155 /*
156  * Debugging
157  */
158 static void     amr_describe_controller(struct amr_softc *sc);
159 #ifdef AMR_DEBUG
160 #if 0
161 static void     amr_printcommand(struct amr_command *ac);
162 #endif
163 #endif
164
165 static void     amr_init_sysctl(struct amr_softc *sc);
166 static int      amr_linux_ioctl_int(struct cdev *dev, u_long cmd, caddr_t addr,
167                     int32_t flag, struct sysmsg *sm);
168
169 static MALLOC_DEFINE(M_AMR, "amr", "AMR memory");
170
171 /********************************************************************************
172  ********************************************************************************
173                                                                       Inline Glue
174  ********************************************************************************
175  ********************************************************************************/
176
177 /********************************************************************************
178  ********************************************************************************
179                                                                 Public Interfaces
180  ********************************************************************************
181  ********************************************************************************/
182
183 /********************************************************************************
184  * Initialise the controller and softc.
185  */
186 int
187 amr_attach(struct amr_softc *sc)
188 {
189     device_t child;
190
191     debug_called(1);
192
193     /*
194      * Initialise per-controller queues.
195      */
196     amr_init_qhead(&sc->amr_freecmds);
197     amr_init_qhead(&sc->amr_ready);
198     TAILQ_INIT(&sc->amr_cmd_clusters);
199     bioq_init(&sc->amr_bioq);
200
201     debug(2, "queue init done");
202
203     /*
204      * Configure for this controller type.
205      */
206     if (AMR_IS_QUARTZ(sc)) {
207         sc->amr_submit_command = amr_quartz_submit_command;
208         sc->amr_get_work       = amr_quartz_get_work;
209         sc->amr_poll_command   = amr_quartz_poll_command;
210         sc->amr_poll_command1  = amr_quartz_poll_command1;
211     } else {
212         sc->amr_submit_command = amr_std_submit_command;
213         sc->amr_get_work       = amr_std_get_work;
214         sc->amr_poll_command   = amr_std_poll_command;
215         amr_std_attach_mailbox(sc);
216     }
217
218 #ifdef AMR_BOARD_INIT
219     if ((AMR_IS_QUARTZ(sc) ? amr_quartz_init(sc) : amr_std_init(sc)))
220         return(ENXIO);
221 #endif
222
223     /*
224      * Allocate initial commands.
225      */
226     amr_alloccmd_cluster(sc);
227
228     /*
229      * Quiz controller for features and limits.
230      */
231     if (amr_query_controller(sc))
232         return(ENXIO);
233
234     debug(2, "controller query complete");
235
236     /*
237      * preallocate the remaining commands.
238      */
239     while (sc->amr_nextslot < sc->amr_maxio)
240         amr_alloccmd_cluster(sc);
241
242     /*
243      * Setup sysctls.
244      */
245     sysctl_ctx_init(&sc->amr_sysctl_ctx);
246     sc->amr_sysctl_tree = SYSCTL_ADD_NODE(&sc->amr_sysctl_ctx,
247         SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
248         device_get_nameunit(sc->amr_dev), CTLFLAG_RD, 0, "");
249     if (sc->amr_sysctl_tree == NULL) {
250         device_printf(sc->amr_dev, "can't add sysctl node\n");
251         return (EINVAL);
252     }
253     amr_init_sysctl(sc);
254
255     /*
256      * Attach our 'real' SCSI channels to CAM.
257      */
258     child = device_add_child(sc->amr_dev, "amrp", -1);
259     sc->amr_pass = child;
260     if (child != NULL) {
261         device_set_softc(child, sc);
262         device_set_desc(child, "SCSI Passthrough Bus");
263         bus_generic_attach(sc->amr_dev);
264     }
265
266     /*
267      * Create the control device.
268      */
269     sc->amr_dev_t = make_dev(&amr_ops, device_get_unit(sc->amr_dev), UID_ROOT, GID_OPERATOR,
270                              S_IRUSR | S_IWUSR, "amr%d", device_get_unit(sc->amr_dev));
271     sc->amr_dev_t->si_drv1 = sc;
272     linux_no_adapter++;
273     if (device_get_unit(sc->amr_dev) == 0)
274         make_dev_alias(sc->amr_dev_t, "megadev0");
275
276     /*
277      * Schedule ourselves to bring the controller up once interrupts are
278      * available.
279      */
280     bzero(&sc->amr_ich, sizeof(struct intr_config_hook));
281     sc->amr_ich.ich_func = amr_startup;
282     sc->amr_ich.ich_arg = sc;
283     sc->amr_ich.ich_desc = "amr";
284     if (config_intrhook_establish(&sc->amr_ich) != 0) {
285         device_printf(sc->amr_dev, "can't establish configuration hook\n");
286         return(ENOMEM);
287     }
288
289     /*
290      * Print a little information about the controller.
291      */
292     amr_describe_controller(sc);
293
294     debug(2, "attach complete");
295     return(0);
296 }
297
298 /********************************************************************************
299  * Locate disk resources and attach children to them.
300  */
301 static void
302 amr_startup(void *arg)
303 {
304     struct amr_softc    *sc = (struct amr_softc *)arg;
305     struct amr_logdrive *dr;
306     int                 i, error;
307     
308     debug_called(1);
309
310     /* pull ourselves off the intrhook chain */
311     if (sc->amr_ich.ich_func)
312         config_intrhook_disestablish(&sc->amr_ich);
313     sc->amr_ich.ich_func = NULL;
314
315     /* get up-to-date drive information */
316     if (amr_query_controller(sc)) {
317         device_printf(sc->amr_dev, "can't scan controller for drives\n");
318         return;
319     }
320
321     /* iterate over available drives */
322     for (i = 0, dr = &sc->amr_drive[0]; (i < AMR_MAXLD) && (dr->al_size != 0xffffffff); i++, dr++) {
323         /* are we already attached to this drive? */
324         if (dr->al_disk == 0) {
325             /* generate geometry information */
326             if (dr->al_size > 0x200000) {       /* extended translation? */
327                 dr->al_heads = 255;
328                 dr->al_sectors = 63;
329             } else {
330                 dr->al_heads = 64;
331                 dr->al_sectors = 32;
332             }
333             dr->al_cylinders = dr->al_size / (dr->al_heads * dr->al_sectors);
334             
335             dr->al_disk = device_add_child(sc->amr_dev, NULL, -1);
336             if (dr->al_disk == 0)
337                 device_printf(sc->amr_dev, "device_add_child failed\n");
338             device_set_ivars(dr->al_disk, dr);
339         }
340     }
341     
342     if ((error = bus_generic_attach(sc->amr_dev)) != 0)
343         device_printf(sc->amr_dev, "bus_generic_attach returned %d\n", error);
344     
345     /* mark controller back up */
346     sc->amr_state &= ~AMR_STATE_SHUTDOWN;
347
348     /* interrupts will be enabled before we do anything more */
349     sc->amr_state |= AMR_STATE_INTEN;
350
351     return;
352 }
353
354 static void
355 amr_init_sysctl(struct amr_softc *sc)
356 {
357
358     SYSCTL_ADD_INT(&sc->amr_sysctl_ctx,
359         SYSCTL_CHILDREN(sc->amr_sysctl_tree),
360         OID_AUTO, "allow_volume_configure", CTLFLAG_RW, &sc->amr_allow_vol_config, 0,
361         "");
362     SYSCTL_ADD_INT(&sc->amr_sysctl_ctx,
363         SYSCTL_CHILDREN(sc->amr_sysctl_tree),
364         OID_AUTO, "nextslot", CTLFLAG_RD, &sc->amr_nextslot, 0,
365         "");
366     SYSCTL_ADD_INT(&sc->amr_sysctl_ctx,
367         SYSCTL_CHILDREN(sc->amr_sysctl_tree),
368         OID_AUTO, "busyslots", CTLFLAG_RD, &sc->amr_busyslots, 0,
369         "");
370     SYSCTL_ADD_INT(&sc->amr_sysctl_ctx,
371         SYSCTL_CHILDREN(sc->amr_sysctl_tree),
372         OID_AUTO, "maxio", CTLFLAG_RD, &sc->amr_maxio, 0,
373         "");
374 }
375
376
377 /*******************************************************************************
378  * Free resources associated with a controller instance
379  */
380 void
381 amr_free(struct amr_softc *sc)
382 {
383     struct amr_command_cluster  *acc;
384
385     /* detach from CAM */
386     if (sc->amr_pass != NULL)
387         device_delete_child(sc->amr_dev, sc->amr_pass);
388
389     /* throw away any command buffers */
390     while ((acc = TAILQ_FIRST(&sc->amr_cmd_clusters)) != NULL) {
391         TAILQ_REMOVE(&sc->amr_cmd_clusters, acc, acc_link);
392         amr_freecmd_cluster(acc);
393     }
394
395     /* destroy control device */
396     if(sc->amr_dev_t != NULL)
397             destroy_dev(sc->amr_dev_t);
398     dev_ops_remove_minor(&amr_ops, device_get_unit(sc->amr_dev));
399
400 #if 0 /* XXX swildner */
401     if (mtx_initialized(&sc->amr_hw_lock))
402         mtx_destroy(&sc->amr_hw_lock);
403
404     if (mtx_initialized(&sc->amr_list_lock))
405         mtx_destroy(&sc->amr_list_lock);
406 #endif
407
408     if (sc->amr_sysctl_tree != NULL)
409             sysctl_ctx_free(&sc->amr_sysctl_ctx);
410
411     lockuninit(&sc->amr_hw_lock);
412     lockuninit(&sc->amr_list_lock);
413 }
414
415 /*******************************************************************************
416  * Receive a bio structure from a child device and queue it on a particular
417  * disk resource, then poke the disk resource to start as much work as it can.
418  */
419 int
420 amr_submit_bio(struct amr_softc *sc, struct bio *bio)
421 {
422     debug_called(2);
423
424     lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
425     amr_enqueue_bio(sc, bio);
426     amr_startio(sc);
427     lockmgr(&sc->amr_list_lock, LK_RELEASE);
428     return(0);
429 }
430
431 /********************************************************************************
432  * Accept an open operation on the control device.
433  */
434 static int
435 amr_open(struct dev_open_args *ap)
436 {
437     cdev_t              dev = ap->a_head.a_dev;
438     int                 unit = minor(dev);
439     struct amr_softc    *sc = devclass_get_softc(devclass_find("amr"), unit);
440
441     debug_called(1);
442
443     sc->amr_state |= AMR_STATE_OPEN;
444     return(0);
445 }
446
447 /********************************************************************************
448  * Accept the last close on the control device.
449  */
450 static int
451 amr_close(struct dev_close_args *ap)
452 {
453     cdev_t              dev = ap->a_head.a_dev;
454     int                 unit = minor(dev);
455     struct amr_softc    *sc = devclass_get_softc(devclass_find("amr"), unit);
456
457     debug_called(1);
458
459     sc->amr_state &= ~AMR_STATE_OPEN;
460     return (0);
461 }
462
463 /********************************************************************************
464  * Handle controller-specific control operations.
465  */
466 static void
467 amr_rescan_drives(struct cdev *dev)
468 {
469     struct amr_softc    *sc = (struct amr_softc *)dev->si_drv1;
470     int                 i, error = 0;
471
472     sc->amr_state |= AMR_STATE_REMAP_LD;
473     while (sc->amr_busyslots) {
474         device_printf(sc->amr_dev, "idle controller\n");
475         amr_done(sc);
476     }
477
478     /* mark ourselves as in-shutdown */
479     sc->amr_state |= AMR_STATE_SHUTDOWN;
480
481     /* flush controller */
482     device_printf(sc->amr_dev, "flushing cache...");
483     kprintf("%s\n", amr_flush(sc) ? "failed" : "done");
484
485     /* delete all our child devices */
486     for(i = 0 ; i < AMR_MAXLD; i++) {
487         if(sc->amr_drive[i].al_disk != 0) {
488             if((error = device_delete_child(sc->amr_dev,
489                 sc->amr_drive[i].al_disk)) != 0)
490                 goto shutdown_out;
491
492              sc->amr_drive[i].al_disk = 0;
493         }
494     }
495
496 shutdown_out:
497     amr_startup(sc);
498 }
499
500 /*
501  * Bug-for-bug compatibility with Linux!
502  * Some apps will send commands with inlen and outlen set to 0,
503  * even though they expect data to be transfered to them from the
504  * card.  Linux accidentally allows this by allocating a 4KB
505  * buffer for the transfer anyways, but it then throws it away
506  * without copying it back to the app.
507  *
508  * The amr(4) firmware relies on this feature.  In fact, it assumes
509  * the buffer is always a power of 2 up to a max of 64k.  There is
510  * also at least one case where it assumes a buffer less than 16k is
511  * greater than 16k.  Force a minimum buffer size of 32k and round
512  * sizes between 32k and 64k up to 64k as a workaround.
513  */
514 static unsigned long
515 amr_ioctl_buffer_length(unsigned long len)
516 {
517
518     if (len <= 32 * 1024)
519         return (32 * 1024);
520     if (len <= 64 * 1024)
521         return (64 * 1024);
522     return (len);
523 }
524
525 int
526 amr_linux_ioctl_int(struct cdev *dev, u_long cmd, caddr_t addr, int32_t flag,
527     struct sysmsg *sm)
528 {
529     struct amr_softc            *sc = (struct amr_softc *)dev->si_drv1;
530     struct amr_command          *ac;
531     struct amr_mailbox          *mb;
532     struct amr_linux_ioctl      ali;
533     void                        *dp, *temp;
534     int                         error;
535     int                         len, ac_flags = 0;
536     int                         logical_drives_changed = 0;
537     u_int32_t                   linux_version = 0x02100000;
538     u_int8_t                    status;
539     struct amr_passthrough      *ap;    /* 60 bytes */
540
541     error = 0;
542     dp = NULL;
543     ac = NULL;
544     ap = NULL;
545
546     if ((error = copyin(addr, &ali, sizeof(ali))) != 0)
547         return (error);
548     switch (ali.ui.fcs.opcode) {
549     case 0x82:
550         switch(ali.ui.fcs.subopcode) {
551         case 'e':
552             copyout(&linux_version, (void *)(uintptr_t)ali.data,
553                 sizeof(linux_version));
554             error = 0;
555             break;
556
557         case 'm':
558             copyout(&linux_no_adapter, (void *)(uintptr_t)ali.data,
559                 sizeof(linux_no_adapter));
560             sm->sm_result.iresult = linux_no_adapter;
561             error = 0;
562             break;
563
564         default:
565             kprintf("Unknown subopcode\n");
566             error = ENOIOCTL;
567             break;
568         }
569     break;
570
571     case 0x80:
572     case 0x81:
573         if (ali.ui.fcs.opcode == 0x80)
574             len = max(ali.outlen, ali.inlen);
575         else
576             len = ali.ui.fcs.length;
577
578         mb = (void *)&ali.mbox[0];
579
580         if ((ali.mbox[0] == FC_DEL_LOGDRV  && ali.mbox[2] == OP_DEL_LOGDRV) ||  /* delete */
581             (ali.mbox[0] == AMR_CMD_CONFIG && ali.mbox[2] == 0x0d)) {           /* create */
582             if (sc->amr_allow_vol_config == 0) {
583                 error = EPERM;
584                 break;
585             }
586             logical_drives_changed = 1;
587         }
588
589         if (ali.mbox[0] == AMR_CMD_PASS) {
590             lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
591             while ((ac = amr_alloccmd(sc)) == NULL)
592                 lksleep(sc, &sc->amr_list_lock, 0, "amrioc", hz);
593             lockmgr(&sc->amr_list_lock, LK_RELEASE);
594             ap = &ac->ac_ccb->ccb_pthru;
595
596             error = copyin((void *)(uintptr_t)mb->mb_physaddr, ap,
597                 sizeof(struct amr_passthrough));
598             if (error)
599                 break;
600
601             if (ap->ap_data_transfer_length)
602                 dp = kmalloc(ap->ap_data_transfer_length, M_AMR,
603                     M_WAITOK | M_ZERO);
604
605             if (ali.inlen) {
606                 error = copyin((void *)(uintptr_t)ap->ap_data_transfer_address,
607                     dp, ap->ap_data_transfer_length);
608                 if (error)
609                     break;
610             }
611
612             ac_flags = AMR_CMD_DATAIN|AMR_CMD_DATAOUT|AMR_CMD_CCB;
613             bzero(&ac->ac_mailbox, sizeof(ac->ac_mailbox));
614             ac->ac_mailbox.mb_command = AMR_CMD_PASS;
615             ac->ac_flags = ac_flags;
616
617             ac->ac_data = dp;
618             ac->ac_length = ap->ap_data_transfer_length;
619             temp = (void *)(uintptr_t)ap->ap_data_transfer_address;
620
621             lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
622             error = amr_wait_command(ac);
623             lockmgr(&sc->amr_list_lock, LK_RELEASE);
624             if (error)
625                 break;
626
627             status = ac->ac_status;
628             error = copyout(&status, &((struct amr_passthrough *)(uintptr_t)mb->mb_physaddr)->ap_scsi_status, sizeof(status));
629             if (error)
630                 break;
631
632             if (ali.outlen) {
633                 error = copyout(dp, temp, ap->ap_data_transfer_length);
634                 if (error)
635                     break;
636             }
637             error = copyout(ap->ap_request_sense_area, ((struct amr_passthrough *)(uintptr_t)mb->mb_physaddr)->ap_request_sense_area, ap->ap_request_sense_length);
638             if (error)
639                 break;
640
641             error = 0;
642             break;
643         } else if (ali.mbox[0] == AMR_CMD_PASS_64) {
644             kprintf("No AMR_CMD_PASS_64\n");
645             error = ENOIOCTL;
646             break;
647         } else if (ali.mbox[0] == AMR_CMD_EXTPASS) {
648             kprintf("No AMR_CMD_EXTPASS\n");
649             error = ENOIOCTL;
650             break;
651         } else {
652             len = amr_ioctl_buffer_length(imax(ali.inlen, ali.outlen));
653
654             dp = kmalloc(len, M_AMR, M_WAITOK | M_ZERO);
655
656             if (ali.inlen) {
657                 error = copyin((void *)(uintptr_t)mb->mb_physaddr, dp, len);
658                 if (error)
659                     break;
660             }
661
662             lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
663             while ((ac = amr_alloccmd(sc)) == NULL)
664                 lksleep(sc, &sc->amr_list_lock, 0, "amrioc", hz);
665
666             ac_flags = AMR_CMD_DATAIN|AMR_CMD_DATAOUT;
667             bzero(&ac->ac_mailbox, sizeof(ac->ac_mailbox));
668             bcopy(&ali.mbox[0], &ac->ac_mailbox, sizeof(ali.mbox));
669
670             ac->ac_length = len;
671             ac->ac_data = dp;
672             ac->ac_flags = ac_flags;
673
674             error = amr_wait_command(ac);
675             lockmgr(&sc->amr_list_lock, LK_RELEASE);
676             if (error)
677                 break;
678
679             status = ac->ac_status;
680             error = copyout(&status, &((struct amr_mailbox *)&((struct amr_linux_ioctl *)addr)->mbox[0])->mb_status, sizeof(status));
681             if (ali.outlen) {
682                 error = copyout(dp, (void *)(uintptr_t)mb->mb_physaddr, ali.outlen);
683                 if (error)
684                     break;
685             }
686
687             error = 0;
688             if (logical_drives_changed)
689                 amr_rescan_drives(dev);
690             break;
691         }
692         break;
693
694     default:
695         debug(1, "unknown linux ioctl 0x%lx", cmd);
696         kprintf("unknown linux ioctl 0x%lx\n", cmd);
697         error = ENOIOCTL;
698         break;
699     }
700
701     /*
702      * At this point, we know that there is a lock held and that these
703      * objects have been allocated.
704      */
705     lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
706     if (ac != NULL)
707         amr_releasecmd(ac);
708     lockmgr(&sc->amr_list_lock, LK_RELEASE);
709     if (dp != NULL)
710         kfree(dp, M_AMR);
711     return(error);
712 }
713
714 static int
715 amr_ioctl(struct dev_ioctl_args *ap)
716 {
717     cdev_t                      dev = ap->a_head.a_dev;
718     caddr_t                     addr = ap->a_data;
719     u_long                      cmd = ap->a_cmd;
720     struct amr_softc            *sc = (struct amr_softc *)dev->si_drv1;
721     union {
722         void                    *_p;
723         struct amr_user_ioctl   *au;
724 #ifdef AMR_IO_COMMAND32
725         struct amr_user_ioctl32 *au32;
726 #endif
727         int                     *result;
728     } arg;
729     struct amr_command          *ac;
730     struct amr_mailbox_ioctl    *mbi;
731     void                        *dp, *au_buffer;
732     unsigned long               au_length, real_length;
733     unsigned char               *au_cmd;
734     int                         *au_statusp;
735     int                         error;
736     struct amr_passthrough      *_ap;   /* 60 bytes */
737     int                         logical_drives_changed = 0;
738
739     debug_called(1);
740
741     arg._p = (void *)addr;
742
743     error = 0;
744     dp = NULL;
745     ac = NULL;
746     _ap = NULL;
747
748     switch(cmd) {
749
750     case AMR_IO_VERSION:
751         debug(1, "AMR_IO_VERSION");
752         *arg.result = AMR_IO_VERSION_NUMBER;
753         return(0);
754
755 #ifdef AMR_IO_COMMAND32
756     /*
757      * Accept ioctl-s from 32-bit binaries on non-32-bit
758      * platforms, such as AMD. LSI's MEGAMGR utility is
759      * the only example known today...  -mi
760      */
761     case AMR_IO_COMMAND32:
762         debug(1, "AMR_IO_COMMAND32 0x%x", arg.au32->au_cmd[0]);
763         au_cmd = arg.au32->au_cmd;
764         au_buffer = (void *)(u_int64_t)arg.au32->au_buffer;
765         au_length = arg.au32->au_length;
766         au_statusp = &arg.au32->au_status;
767         break;
768 #endif
769
770     case AMR_IO_COMMAND:
771         debug(1, "AMR_IO_COMMAND  0x%x", arg.au->au_cmd[0]);
772         au_cmd = arg.au->au_cmd;
773         au_buffer = (void *)arg.au->au_buffer;
774         au_length = arg.au->au_length;
775         au_statusp = &arg.au->au_status;
776         break;
777
778     case 0xc0046d00:
779     case 0xc06e6d00:    /* Linux emulation */
780         {
781             devclass_t                  devclass;
782             struct amr_linux_ioctl      ali;
783             int                         adapter, error;
784
785             devclass = devclass_find("amr");
786             if (devclass == NULL)
787                 return (ENOENT);
788
789             error = copyin(addr, &ali, sizeof(ali));
790             if (error)
791                 return (error);
792             if (ali.ui.fcs.opcode == 0x82)
793                 adapter = 0;
794             else
795                 adapter = (ali.ui.fcs.adapno) ^ 'm' << 8;
796
797             sc = devclass_get_softc(devclass, adapter);
798             if (sc == NULL)
799                 return (ENOENT);
800
801             return (amr_linux_ioctl_int(sc->amr_dev_t, cmd, addr, 0, ap->a_sysmsg));
802         }
803     default:
804         debug(1, "unknown ioctl 0x%lx", cmd);
805         return(ENOIOCTL);
806     }
807
808     if ((au_cmd[0] == FC_DEL_LOGDRV && au_cmd[1] == OP_DEL_LOGDRV) ||   /* delete */
809         (au_cmd[0] == AMR_CMD_CONFIG && au_cmd[1] == 0x0d)) {           /* create */
810         if (sc->amr_allow_vol_config == 0) {
811             error = EPERM;
812             goto out;
813         }
814         logical_drives_changed = 1;
815     }
816
817     /* handle inbound data buffer */
818     real_length = amr_ioctl_buffer_length(au_length);
819     if (au_length != 0 && au_cmd[0] != 0x06) {
820         if ((dp = kmalloc(real_length, M_AMR, M_WAITOK|M_ZERO)) == NULL) {
821             error = ENOMEM;
822             goto out;
823         }
824         if ((error = copyin(au_buffer, dp, au_length)) != 0) {
825             kfree(dp, M_AMR);
826             return (error);
827         }
828         debug(2, "copyin %ld bytes from %p -> %p", au_length, au_buffer, dp);
829     }
830
831     /* Allocate this now before the mutex gets held */
832
833     lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
834     while ((ac = amr_alloccmd(sc)) == NULL)
835         lksleep(sc, &sc->amr_list_lock, 0, "amrioc", hz);
836
837     /* handle SCSI passthrough command */
838     if (au_cmd[0] == AMR_CMD_PASS) {
839         int len;
840
841         _ap = &ac->ac_ccb->ccb_pthru;
842         bzero(_ap, sizeof(struct amr_passthrough));
843
844         /* copy cdb */
845         len = au_cmd[2];
846         _ap->ap_cdb_length = len;
847         bcopy(au_cmd + 3, _ap->ap_cdb, len);
848
849         /* build passthrough */
850         _ap->ap_timeout         = au_cmd[len + 3] & 0x07;
851         _ap->ap_ars             = (au_cmd[len + 3] & 0x08) ? 1 : 0;
852         _ap->ap_islogical       = (au_cmd[len + 3] & 0x80) ? 1 : 0;
853         _ap->ap_logical_drive_no = au_cmd[len + 4];
854         _ap->ap_channel         = au_cmd[len + 5];
855         _ap->ap_scsi_id         = au_cmd[len + 6];
856         _ap->ap_request_sense_length    = 14;
857         _ap->ap_data_transfer_length    = au_length;
858         /* XXX what about the request-sense area? does the caller want it? */
859
860         /* build command */
861         ac->ac_mailbox.mb_command = AMR_CMD_PASS;
862         ac->ac_flags = AMR_CMD_CCB;
863
864     } else {
865         /* direct command to controller */
866         mbi = (struct amr_mailbox_ioctl *)&ac->ac_mailbox;
867
868         /* copy pertinent mailbox items */
869         mbi->mb_command = au_cmd[0];
870         mbi->mb_channel = au_cmd[1];
871         mbi->mb_param = au_cmd[2];
872         mbi->mb_pad[0] = au_cmd[3];
873         mbi->mb_drive = au_cmd[4];
874         ac->ac_flags = 0;
875     }
876
877     /* build the command */
878     ac->ac_data = dp;
879     ac->ac_length = real_length;
880     ac->ac_flags |= AMR_CMD_DATAIN|AMR_CMD_DATAOUT;
881
882     /* run the command */
883     error = amr_wait_command(ac);
884     lockmgr(&sc->amr_list_lock, LK_RELEASE);
885     if (error)
886         goto out;
887
888     /* copy out data and set status */
889     if (au_length != 0) {
890         error = copyout(dp, au_buffer, au_length);
891     }
892     debug(2, "copyout %ld bytes from %p -> %p", au_length, dp, au_buffer);
893     if (dp != NULL)
894         debug(2, "%p status 0x%x", dp, ac->ac_status);
895     *au_statusp = ac->ac_status;
896
897 out:
898     /*
899      * At this point, we know that there is a lock held and that these
900      * objects have been allocated.
901      */
902     lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
903     if (ac != NULL)
904         amr_releasecmd(ac);
905     lockmgr(&sc->amr_list_lock, LK_RELEASE);
906     if (dp != NULL)
907         kfree(dp, M_AMR);
908
909     if (logical_drives_changed)
910         amr_rescan_drives(dev);
911
912     return(error);
913 }
914
915 /********************************************************************************
916  ********************************************************************************
917                                                                  Command Wrappers
918  ********************************************************************************
919  ********************************************************************************/
920
921 /********************************************************************************
922  * Interrogate the controller for the operational parameters we require.
923  */
924 static int
925 amr_query_controller(struct amr_softc *sc)
926 {
927     struct amr_enquiry3 *aex;
928     struct amr_prodinfo *ap;
929     struct amr_enquiry  *ae;
930     int                 ldrv;
931     int                 status;
932
933     /*
934      * Greater than 10 byte cdb support
935      */
936     sc->support_ext_cdb = amr_support_ext_cdb(sc);
937
938     if(sc->support_ext_cdb) {
939         debug(2,"supports extended CDBs.");
940     }
941
942     /* 
943      * Try to issue an ENQUIRY3 command 
944      */
945     if ((aex = amr_enquiry(sc, 2048, AMR_CMD_CONFIG, AMR_CONFIG_ENQ3, 
946                            AMR_CONFIG_ENQ3_SOLICITED_FULL, &status)) != NULL) {
947
948         /*
949          * Fetch current state of logical drives.
950          */
951         for (ldrv = 0; ldrv < aex->ae_numldrives; ldrv++) {
952             sc->amr_drive[ldrv].al_size       = aex->ae_drivesize[ldrv];
953             sc->amr_drive[ldrv].al_state      = aex->ae_drivestate[ldrv];
954             sc->amr_drive[ldrv].al_properties = aex->ae_driveprop[ldrv];
955             debug(2, "  drive %d: %d state %x properties %x", ldrv, sc->amr_drive[ldrv].al_size,
956                   sc->amr_drive[ldrv].al_state, sc->amr_drive[ldrv].al_properties);
957         }
958         kfree(aex, M_AMR);
959
960         /*
961          * Get product info for channel count.
962          */
963         if ((ap = amr_enquiry(sc, 2048, AMR_CMD_CONFIG, AMR_CONFIG_PRODUCT_INFO, 0, &status)) == NULL) {
964             device_printf(sc->amr_dev, "can't obtain product data from controller\n");
965             return(1);
966         }
967         sc->amr_maxdrives = 40;
968         sc->amr_maxchan = ap->ap_nschan;
969         sc->amr_maxio = ap->ap_maxio;
970         sc->amr_type |= AMR_TYPE_40LD;
971         kfree(ap, M_AMR);
972
973         ap = amr_enquiry(sc, 0, FC_DEL_LOGDRV, OP_SUP_DEL_LOGDRV, 0, &status);
974         if (ap != NULL)
975             kfree(ap, M_AMR);
976         if (!status) {
977             sc->amr_ld_del_supported = 1;
978             device_printf(sc->amr_dev, "delete logical drives supported by controller\n");
979         }
980     } else {
981
982         /* failed, try the 8LD ENQUIRY commands */
983         if ((ae = (struct amr_enquiry *)amr_enquiry(sc, 2048, AMR_CMD_EXT_ENQUIRY2, 0, 0, &status)) == NULL) {
984             if ((ae = (struct amr_enquiry *)amr_enquiry(sc, 2048, AMR_CMD_ENQUIRY, 0, 0, &status)) == NULL) {
985                 device_printf(sc->amr_dev, "can't obtain configuration data from controller\n");
986                 return(1);
987             }
988             ae->ae_signature = 0;
989         }
990
991         /*
992          * Fetch current state of logical drives.
993          */
994         for (ldrv = 0; ldrv < ae->ae_ldrv.al_numdrives; ldrv++) {
995             sc->amr_drive[ldrv].al_size       = ae->ae_ldrv.al_size[ldrv];
996             sc->amr_drive[ldrv].al_state      = ae->ae_ldrv.al_state[ldrv];
997             sc->amr_drive[ldrv].al_properties = ae->ae_ldrv.al_properties[ldrv];
998             debug(2, "  drive %d: %d state %x properties %x\n", ldrv, sc->amr_drive[ldrv].al_size,
999                   sc->amr_drive[ldrv].al_state, sc->amr_drive[ldrv].al_properties);
1000         }
1001
1002         sc->amr_maxdrives = 8;
1003         sc->amr_maxchan = ae->ae_adapter.aa_channels;
1004         sc->amr_maxio = ae->ae_adapter.aa_maxio;
1005         kfree(ae, M_AMR);
1006     }
1007
1008     /*
1009      * Mark remaining drives as unused.
1010      */
1011     for (; ldrv < AMR_MAXLD; ldrv++)
1012         sc->amr_drive[ldrv].al_size = 0xffffffff;
1013
1014     /* 
1015      * Cap the maximum number of outstanding I/Os.  AMI's Linux driver doesn't trust
1016      * the controller's reported value, and lockups have been seen when we do.
1017      */
1018     sc->amr_maxio = imin(sc->amr_maxio, AMR_LIMITCMD);
1019
1020     return(0);
1021 }
1022
1023 /********************************************************************************
1024  * Run a generic enquiry-style command.
1025  */
1026 static void *
1027 amr_enquiry(struct amr_softc *sc, size_t bufsize, u_int8_t cmd, u_int8_t cmdsub, u_int8_t cmdqual, int *status)
1028 {
1029     struct amr_command  *ac;
1030     void                *result;
1031     u_int8_t            *mbox;
1032     int                 error;
1033
1034     debug_called(1);
1035
1036     error = 1;
1037     result = NULL;
1038     
1039     /* get ourselves a command buffer */
1040     lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
1041     ac = amr_alloccmd(sc);
1042     lockmgr(&sc->amr_list_lock, LK_RELEASE);
1043     if (ac == NULL)
1044         goto out;
1045     /* allocate the response structure */
1046     if ((result = kmalloc(bufsize, M_AMR, M_ZERO|M_NOWAIT)) == NULL)
1047         goto out;
1048     /* set command flags */
1049
1050     ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAIN;
1051     
1052     /* point the command at our data */
1053     ac->ac_data = result;
1054     ac->ac_length = bufsize;
1055     
1056     /* build the command proper */
1057     mbox = (u_int8_t *)&ac->ac_mailbox;         /* XXX want a real structure for this? */
1058     mbox[0] = cmd;
1059     mbox[2] = cmdsub;
1060     mbox[3] = cmdqual;
1061     *status = 0;
1062
1063     /* can't assume that interrupts are going to work here, so play it safe */
1064     if (sc->amr_poll_command(ac))
1065         goto out;
1066     error = ac->ac_status;
1067     *status = ac->ac_status;
1068     
1069  out:
1070     lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
1071     if (ac != NULL)
1072         amr_releasecmd(ac);
1073     lockmgr(&sc->amr_list_lock, LK_RELEASE);
1074     if ((error != 0) && (result != NULL)) {
1075         kfree(result, M_AMR);
1076         result = NULL;
1077     }
1078     return(result);
1079 }
1080
1081 /********************************************************************************
1082  * Flush the controller's internal cache, return status.
1083  */
1084 int
1085 amr_flush(struct amr_softc *sc)
1086 {
1087     struct amr_command  *ac;
1088     int                 error;
1089
1090     /* get ourselves a command buffer */
1091     error = 1;
1092     lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
1093     ac = amr_alloccmd(sc);
1094     lockmgr(&sc->amr_list_lock, LK_RELEASE);
1095     if (ac == NULL)
1096         goto out;
1097     /* set command flags */
1098     ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT;
1099     
1100     /* build the command proper */
1101     ac->ac_mailbox.mb_command = AMR_CMD_FLUSH;
1102
1103     /* we have to poll, as the system may be going down or otherwise damaged */
1104     if (sc->amr_poll_command(ac))
1105         goto out;
1106     error = ac->ac_status;
1107     
1108  out:
1109     lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
1110     if (ac != NULL)
1111         amr_releasecmd(ac);
1112     lockmgr(&sc->amr_list_lock, LK_RELEASE);
1113     return(error);
1114 }
1115
1116 /********************************************************************************
1117  * Detect extented cdb >> greater than 10 byte cdb support
1118  * returns '1' means this support exist
1119  * returns '0' means this support doesn't exist
1120  */
1121 static int
1122 amr_support_ext_cdb(struct amr_softc *sc)
1123 {
1124     struct amr_command  *ac;
1125     u_int8_t            *mbox;
1126     int                 error;
1127
1128     /* get ourselves a command buffer */
1129     error = 0;
1130     lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
1131     ac = amr_alloccmd(sc);
1132     lockmgr(&sc->amr_list_lock, LK_RELEASE);
1133     if (ac == NULL)
1134         goto out;
1135     /* set command flags */
1136     ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT;
1137
1138     /* build the command proper */
1139     mbox = (u_int8_t *)&ac->ac_mailbox;         /* XXX want a real structure for this? */
1140     mbox[0] = 0xA4;
1141     mbox[2] = 0x16;
1142
1143
1144     /* we have to poll, as the system may be going down or otherwise damaged */
1145     if (sc->amr_poll_command(ac))
1146         goto out;
1147     if( ac->ac_status == AMR_STATUS_SUCCESS ) {
1148             error = 1;
1149     }
1150
1151 out:
1152     lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
1153     if (ac != NULL)
1154         amr_releasecmd(ac);
1155     lockmgr(&sc->amr_list_lock, LK_RELEASE);
1156     return(error);
1157 }
1158
1159 /********************************************************************************
1160  * Try to find I/O work for the controller from one or more of the work queues.
1161  *
1162  * We make the assumption that if the controller is not ready to take a command
1163  * at some given time, it will generate an interrupt at some later time when
1164  * it is.
1165  */
1166 void
1167 amr_startio(struct amr_softc *sc)
1168 {
1169     struct amr_command  *ac;
1170
1171     /* spin until something prevents us from doing any work */
1172     for (;;) {
1173
1174         /* Don't bother to queue commands no bounce buffers are available. */
1175         if (sc->amr_state & AMR_STATE_QUEUE_FRZN)
1176             break;
1177
1178         /* try to get a ready command */
1179         ac = amr_dequeue_ready(sc);
1180
1181         /* if that failed, build a command from a bio */
1182         if (ac == NULL)
1183             (void)amr_bio_command(sc, &ac);
1184
1185         /* if that failed, build a command from a ccb */
1186         if ((ac == NULL) && (sc->amr_cam_command != NULL))
1187             sc->amr_cam_command(sc, &ac);
1188
1189         /* if we don't have anything to do, give up */
1190         if (ac == NULL)
1191             break;
1192
1193         /* try to give the command to the controller; if this fails save it for later and give up */
1194         if (amr_start(ac)) {
1195             debug(2, "controller busy, command deferred");
1196             amr_requeue_ready(ac);      /* XXX schedule retry very soon? */
1197             break;
1198         }
1199     }
1200 }
1201
1202 /********************************************************************************
1203  * Handle completion of an I/O command.
1204  */
1205 static void
1206 amr_completeio(struct amr_command *ac)
1207 {
1208     struct amr_softc            *sc = ac->ac_sc;
1209     static struct timeval       lastfail;
1210     static int                  curfail;
1211     struct buf                  *bp = ac->ac_bio->bio_buf;
1212
1213     if (ac->ac_status != AMR_STATUS_SUCCESS) {  /* could be more verbose here? */
1214         bp->b_error = EIO;
1215         bp->b_flags |= B_ERROR;
1216
1217         if (ppsratecheck(&lastfail, &curfail, 1))
1218             device_printf(sc->amr_dev, "I/O error - 0x%x\n", ac->ac_status);
1219 /*      amr_printcommand(ac);*/
1220     }
1221     amrd_intr(ac->ac_bio);
1222     lockmgr(&ac->ac_sc->amr_list_lock, LK_EXCLUSIVE);
1223     amr_releasecmd(ac);
1224     lockmgr(&ac->ac_sc->amr_list_lock, LK_RELEASE);
1225 }
1226
1227 /********************************************************************************
1228  ********************************************************************************
1229                                                                Command Processing
1230  ********************************************************************************
1231  ********************************************************************************/
1232
1233 /********************************************************************************
1234  * Convert a bio off the top of the bio queue into a command.
1235  */
1236 static int
1237 amr_bio_command(struct amr_softc *sc, struct amr_command **acp)
1238 {
1239     struct amr_command  *ac;
1240     struct amrd_softc   *amrd;
1241     struct bio          *bio;
1242     struct buf          *bp;
1243     int                 error;
1244     int                 blkcount;
1245     int                 driveno;
1246     int                 cmd;
1247
1248     ac = NULL;
1249     error = 0;
1250
1251     /* get a command */
1252     if ((ac = amr_alloccmd(sc)) == NULL)
1253         return (ENOMEM);
1254
1255     /* get a bio to work on */
1256     if ((bio = amr_dequeue_bio(sc)) == NULL) {
1257         amr_releasecmd(ac);
1258         return (0);
1259     }
1260
1261     /* connect the bio to the command */
1262     bp = bio->bio_buf;
1263     ac->ac_complete = amr_completeio;
1264     ac->ac_bio = bio;
1265     ac->ac_data = bp->b_data;
1266     ac->ac_length = bp->b_bcount;
1267     cmd = 0;
1268     switch (bp->b_cmd) {
1269     case BUF_CMD_READ:
1270         ac->ac_flags |= AMR_CMD_DATAIN;
1271         if (AMR_IS_SG64(sc)) {
1272             cmd = AMR_CMD_LREAD64;
1273             ac->ac_flags |= AMR_CMD_SG64;
1274         } else
1275             cmd = AMR_CMD_LREAD;
1276         break;
1277     case BUF_CMD_WRITE:
1278         ac->ac_flags |= AMR_CMD_DATAOUT;
1279         if (AMR_IS_SG64(sc)) {
1280             cmd = AMR_CMD_LWRITE64;
1281             ac->ac_flags |= AMR_CMD_SG64;
1282         } else
1283             cmd = AMR_CMD_LWRITE;
1284         break;
1285     case BUF_CMD_FLUSH:
1286         ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT;
1287         cmd = AMR_CMD_FLUSH;
1288         break;
1289     default:
1290         panic("Invalid bio command");
1291     }
1292     amrd = (struct amrd_softc *)bio->bio_driver_info;
1293     driveno = amrd->amrd_drive - sc->amr_drive;
1294     blkcount = (bp->b_bcount + AMR_BLKSIZE - 1) / AMR_BLKSIZE;
1295
1296     ac->ac_mailbox.mb_command = cmd;
1297     if (bp->b_cmd & (BUF_CMD_READ|BUF_CMD_WRITE)) {
1298         ac->ac_mailbox.mb_blkcount = blkcount;
1299         ac->ac_mailbox.mb_lba = bio->bio_offset / AMR_BLKSIZE;
1300         if (((bio->bio_offset / AMR_BLKSIZE) + blkcount) > sc->amr_drive[driveno].al_size) {
1301             device_printf(sc->amr_dev,
1302                           "I/O beyond end of unit (%lld,%d > %lu)\n",
1303                           (long long)(bio->bio_offset / AMR_BLKSIZE), blkcount,
1304                           (u_long)sc->amr_drive[driveno].al_size);
1305         }
1306     }
1307     ac->ac_mailbox.mb_drive = driveno;
1308     if (sc->amr_state & AMR_STATE_REMAP_LD)
1309         ac->ac_mailbox.mb_drive |= 0x80;
1310
1311     /* we fill in the s/g related data when the command is mapped */
1312
1313
1314     *acp = ac;
1315     return(error);
1316 }
1317
1318 /********************************************************************************
1319  * Take a command, submit it to the controller and sleep until it completes
1320  * or fails.  Interrupts must be enabled, returns nonzero on error.
1321  */
1322 static int
1323 amr_wait_command(struct amr_command *ac)
1324 {
1325     int                 error = 0;
1326     struct amr_softc    *sc = ac->ac_sc;
1327
1328     debug_called(1);
1329
1330     ac->ac_complete = NULL;
1331     ac->ac_flags |= AMR_CMD_SLEEP;
1332     if ((error = amr_start(ac)) != 0) {
1333         return(error);
1334     }
1335     
1336     while ((ac->ac_flags & AMR_CMD_BUSY) && (error != EWOULDBLOCK)) {
1337         error = lksleep(ac,&sc->amr_list_lock, 0, "amrwcmd", 0);
1338     }
1339
1340     return(error);
1341 }
1342
1343 /********************************************************************************
1344  * Take a command, submit it to the controller and busy-wait for it to return.
1345  * Returns nonzero on error.  Can be safely called with interrupts enabled.
1346  */
1347 static int
1348 amr_std_poll_command(struct amr_command *ac)
1349 {
1350     struct amr_softc    *sc = ac->ac_sc;
1351     int                 error, count;
1352
1353     debug_called(2);
1354
1355     ac->ac_complete = NULL;
1356     if ((error = amr_start(ac)) != 0)
1357         return(error);
1358
1359     count = 0;
1360     do {
1361         /* 
1362          * Poll for completion, although the interrupt handler may beat us to it. 
1363          * Note that the timeout here is somewhat arbitrary.
1364          */
1365         amr_done(sc);
1366         DELAY(1000);
1367     } while ((ac->ac_flags & AMR_CMD_BUSY) && (count++ < 1000));
1368     if (!(ac->ac_flags & AMR_CMD_BUSY)) {
1369         error = 0;
1370     } else {
1371         /* XXX the slot is now marked permanently busy */
1372         error = EIO;
1373         device_printf(sc->amr_dev, "polled command timeout\n");
1374     }
1375     return(error);
1376 }
1377
1378 static void
1379 amr_setup_polled_dmamap(void *arg, bus_dma_segment_t *segs, int nsegs, int err)
1380 {
1381     struct amr_command *ac = arg;
1382     struct amr_softc *sc = ac->ac_sc;
1383     int mb_channel;
1384
1385     if (err) {
1386         device_printf(sc->amr_dev, "error %d in %s", err, __func__);
1387         ac->ac_status = AMR_STATUS_ABORTED;
1388         return;
1389     }
1390
1391     amr_setup_sg(arg, segs, nsegs, err);
1392
1393     /* for AMR_CMD_CONFIG Read/Write the s/g count goes elsewhere */
1394     mb_channel = ((struct amr_mailbox_ioctl *)&ac->ac_mailbox)->mb_channel;
1395     if (ac->ac_mailbox.mb_command == AMR_CMD_CONFIG &&
1396         ((mb_channel == AMR_CONFIG_READ_NVRAM_CONFIG) ||
1397         (mb_channel == AMR_CONFIG_WRITE_NVRAM_CONFIG)))
1398         ((struct amr_mailbox_ioctl *)&ac->ac_mailbox)->mb_param = ac->ac_nsegments;
1399
1400     ac->ac_mailbox.mb_nsgelem = ac->ac_nsegments;
1401     ac->ac_mailbox.mb_physaddr = ac->ac_mb_physaddr;
1402     if (AC_IS_SG64(ac)) {
1403         ac->ac_sg64_hi = 0;
1404         ac->ac_sg64_lo = ac->ac_sgbusaddr;
1405     }
1406
1407     sc->amr_poll_command1(sc, ac);
1408 }
1409
1410 /********************************************************************************
1411  * Take a command, submit it to the controller and busy-wait for it to return.
1412  * Returns nonzero on error.  Can be safely called with interrupts enabled.
1413  */
1414 static int
1415 amr_quartz_poll_command(struct amr_command *ac)
1416 {
1417     struct amr_softc    *sc = ac->ac_sc;
1418     int                 error;
1419
1420     debug_called(2);
1421
1422     error = 0;
1423
1424     if (AC_IS_SG64(ac)) {
1425         ac->ac_tag = sc->amr_buffer64_dmat;
1426         ac->ac_datamap = ac->ac_dma64map;
1427     } else {
1428         ac->ac_tag = sc->amr_buffer_dmat;
1429         ac->ac_datamap = ac->ac_dmamap;
1430     }
1431
1432     /* now we have a slot, we can map the command (unmapped in amr_complete) */
1433     if (ac->ac_data != NULL && ac->ac_length != 0) {
1434         if (bus_dmamap_load(ac->ac_tag, ac->ac_datamap, ac->ac_data,
1435             ac->ac_length, amr_setup_polled_dmamap, ac, BUS_DMA_NOWAIT) != 0) {
1436             error = 1;
1437         }
1438     } else {
1439         error = amr_quartz_poll_command1(sc, ac);
1440     }
1441
1442     return (error);
1443 }
1444
1445 static int
1446 amr_quartz_poll_command1(struct amr_softc *sc, struct amr_command *ac)
1447 {
1448     int count, error;
1449
1450     lockmgr(&sc->amr_hw_lock, LK_EXCLUSIVE);
1451     if ((sc->amr_state & AMR_STATE_INTEN) == 0) {
1452         count=0;
1453         while (sc->amr_busyslots) {
1454             lksleep(sc, &sc->amr_hw_lock, PCATCH, "amrpoll", hz);
1455             if(count++>10) {
1456                 break;
1457             }
1458         }
1459
1460         if(sc->amr_busyslots) {
1461             device_printf(sc->amr_dev, "adapter is busy\n");
1462             lockmgr(&sc->amr_hw_lock, LK_RELEASE);
1463             if (ac->ac_data != NULL) {
1464                 bus_dmamap_unload(ac->ac_tag, ac->ac_datamap);
1465             }
1466             ac->ac_status=0;
1467             return(1);
1468         }
1469     }
1470
1471     bcopy(&ac->ac_mailbox, (void *)(uintptr_t)(volatile void *)sc->amr_mailbox, AMR_MBOX_CMDSIZE);
1472
1473     /* clear the poll/ack fields in the mailbox */
1474     sc->amr_mailbox->mb_ident = 0xFE;
1475     sc->amr_mailbox->mb_nstatus = 0xFF;
1476     sc->amr_mailbox->mb_status = 0xFF;
1477     sc->amr_mailbox->mb_poll = 0;
1478     sc->amr_mailbox->mb_ack = 0;
1479     sc->amr_mailbox->mb_busy = 1;
1480
1481     AMR_QPUT_IDB(sc, sc->amr_mailboxphys | AMR_QIDB_SUBMIT);
1482
1483     while(sc->amr_mailbox->mb_nstatus == 0xFF)
1484         DELAY(1);
1485     while(sc->amr_mailbox->mb_status == 0xFF)
1486         DELAY(1);
1487     ac->ac_status=sc->amr_mailbox->mb_status;
1488     error = (ac->ac_status !=AMR_STATUS_SUCCESS) ? 1:0;
1489     while(sc->amr_mailbox->mb_poll != 0x77)
1490         DELAY(1);
1491     sc->amr_mailbox->mb_poll = 0;
1492     sc->amr_mailbox->mb_ack = 0x77;
1493
1494     /* acknowledge that we have the commands */
1495     AMR_QPUT_IDB(sc, sc->amr_mailboxphys | AMR_QIDB_ACK);
1496     while(AMR_QGET_IDB(sc) & AMR_QIDB_ACK)
1497         DELAY(1);
1498     lockmgr(&sc->amr_hw_lock, LK_RELEASE);
1499
1500     /* unmap the command's data buffer */
1501     if (ac->ac_flags & AMR_CMD_DATAIN) {
1502         bus_dmamap_sync(ac->ac_tag, ac->ac_datamap, BUS_DMASYNC_POSTREAD);
1503     }
1504     if (ac->ac_flags & AMR_CMD_DATAOUT) {
1505         bus_dmamap_sync(ac->ac_tag, ac->ac_datamap, BUS_DMASYNC_POSTWRITE);
1506     }
1507     bus_dmamap_unload(ac->ac_tag, ac->ac_datamap);
1508
1509     return(error);
1510 }
1511
1512 static __inline int
1513 amr_freeslot(struct amr_command *ac)
1514 {
1515     struct amr_softc *sc = ac->ac_sc;
1516     int                 slot;
1517
1518     debug_called(3);
1519
1520     slot = ac->ac_slot;
1521     if (sc->amr_busycmd[slot] == NULL)
1522         panic("amr: slot %d not busy?", slot);
1523
1524     sc->amr_busycmd[slot] = NULL;
1525     atomic_subtract_int(&sc->amr_busyslots, 1);
1526
1527     return (0);
1528 }
1529
1530 /********************************************************************************
1531  * Map/unmap (ac)'s data in the controller's addressable space as required.
1532  *
1533  * These functions may be safely called multiple times on a given command.
1534  */
1535 static void
1536 amr_setup_sg(void *arg, bus_dma_segment_t *segs, int nsegments, int error)
1537 {
1538     struct amr_command  *ac = (struct amr_command *)arg;
1539     struct amr_sgentry  *sg;
1540     struct amr_sg64entry *sg64;
1541     int flags, i;
1542
1543     debug_called(3);
1544
1545     /* get base address of s/g table */
1546     sg = ac->ac_sg.sg32;
1547     sg64 = ac->ac_sg.sg64;
1548
1549     if (AC_IS_SG64(ac)) {
1550         ac->ac_nsegments = nsegments;
1551         ac->ac_mb_physaddr = 0xffffffff;
1552         for (i = 0; i < nsegments; i++, sg64++) {
1553             sg64->sg_addr = segs[i].ds_addr;
1554             sg64->sg_count = segs[i].ds_len;
1555         }
1556     } else {
1557         /* decide whether we need to populate the s/g table */
1558         if (nsegments < 2) {
1559             ac->ac_nsegments = 0;
1560             ac->ac_mb_physaddr = segs[0].ds_addr;
1561         } else {
1562             ac->ac_nsegments = nsegments;
1563             ac->ac_mb_physaddr = ac->ac_sgbusaddr;
1564             for (i = 0; i < nsegments; i++, sg++) {
1565                 sg->sg_addr = segs[i].ds_addr;
1566                 sg->sg_count = segs[i].ds_len;
1567             }
1568         }
1569     }
1570
1571     flags = 0;
1572     if (ac->ac_flags & AMR_CMD_DATAIN)
1573         flags |= BUS_DMASYNC_PREREAD;
1574     if (ac->ac_flags & AMR_CMD_DATAOUT)
1575         flags |= BUS_DMASYNC_PREWRITE;
1576     bus_dmamap_sync(ac->ac_tag, ac->ac_datamap, flags);
1577     ac->ac_flags |= AMR_CMD_MAPPED;
1578 }
1579
1580 static void
1581 amr_setup_data(void *arg, bus_dma_segment_t *segs, int nsegs, int err)
1582 {
1583     struct amr_command *ac = arg;
1584     struct amr_softc *sc = ac->ac_sc;
1585     int mb_channel;
1586
1587     if (err) {
1588         device_printf(sc->amr_dev, "error %d in %s", err, __func__);
1589         amr_abort_load(ac);
1590         return;
1591     }
1592
1593     amr_setup_sg(arg, segs, nsegs, err);
1594
1595     /* for AMR_CMD_CONFIG Read/Write the s/g count goes elsewhere */
1596     mb_channel = ((struct amr_mailbox_ioctl *)&ac->ac_mailbox)->mb_channel;
1597     if (ac->ac_mailbox.mb_command == AMR_CMD_CONFIG &&
1598         ((mb_channel == AMR_CONFIG_READ_NVRAM_CONFIG) ||
1599         (mb_channel == AMR_CONFIG_WRITE_NVRAM_CONFIG)))
1600         ((struct amr_mailbox_ioctl *)&ac->ac_mailbox)->mb_param = ac->ac_nsegments;
1601
1602     ac->ac_mailbox.mb_nsgelem = ac->ac_nsegments;
1603     ac->ac_mailbox.mb_physaddr = ac->ac_mb_physaddr;
1604     if (AC_IS_SG64(ac)) {
1605         ac->ac_sg64_hi = 0;
1606         ac->ac_sg64_lo = ac->ac_sgbusaddr;
1607     }
1608
1609     if (sc->amr_submit_command(ac) == EBUSY) {
1610         amr_freeslot(ac);
1611         amr_requeue_ready(ac);
1612     }
1613 }
1614
1615 static void
1616 amr_setup_ccb(void *arg, bus_dma_segment_t *segs, int nsegs, int err)
1617 {
1618     struct amr_command *ac = arg;
1619     struct amr_softc *sc = ac->ac_sc;
1620     struct amr_passthrough *ap = &ac->ac_ccb->ccb_pthru;
1621     struct amr_ext_passthrough *aep = &ac->ac_ccb->ccb_epthru;
1622
1623     if (err) {
1624         device_printf(sc->amr_dev, "error %d in %s", err, __func__);
1625         amr_abort_load(ac);
1626         return;
1627     }
1628
1629     /* Set up the mailbox portion of the command to point at the ccb */
1630     ac->ac_mailbox.mb_nsgelem = 0;
1631     ac->ac_mailbox.mb_physaddr = ac->ac_ccb_busaddr;
1632
1633     amr_setup_sg(arg, segs, nsegs, err);
1634
1635     switch (ac->ac_mailbox.mb_command) {
1636     case AMR_CMD_EXTPASS:
1637         aep->ap_no_sg_elements = ac->ac_nsegments;
1638         aep->ap_data_transfer_address = ac->ac_mb_physaddr;
1639         break;
1640     case AMR_CMD_PASS:
1641         ap->ap_no_sg_elements = ac->ac_nsegments;
1642         ap->ap_data_transfer_address = ac->ac_mb_physaddr;
1643         break;
1644     default:
1645         panic("Unknown ccb command");
1646     }
1647
1648     if (sc->amr_submit_command(ac) == EBUSY) {
1649         amr_freeslot(ac);
1650         amr_requeue_ready(ac);
1651     }
1652 }
1653
1654 static int
1655 amr_mapcmd(struct amr_command *ac)
1656 {
1657     bus_dmamap_callback_t *cb;
1658     struct amr_softc    *sc = ac->ac_sc;
1659
1660     debug_called(3);
1661
1662     if (AC_IS_SG64(ac)) {
1663         ac->ac_tag = sc->amr_buffer64_dmat;
1664         ac->ac_datamap = ac->ac_dma64map;
1665     } else {
1666         ac->ac_tag = sc->amr_buffer_dmat;
1667         ac->ac_datamap = ac->ac_dmamap;
1668     }
1669
1670     if (ac->ac_flags & AMR_CMD_CCB)
1671         cb = amr_setup_ccb;
1672     else
1673         cb = amr_setup_data;
1674
1675     /* if the command involves data at all, and hasn't been mapped */
1676     if ((ac->ac_flags & AMR_CMD_MAPPED) == 0 && (ac->ac_data != NULL)) {
1677         /* map the data buffers into bus space and build the s/g list */
1678         if (bus_dmamap_load(ac->ac_tag, ac->ac_datamap, ac->ac_data,
1679              ac->ac_length, cb, ac, 0) == EINPROGRESS) {
1680             sc->amr_state |= AMR_STATE_QUEUE_FRZN;
1681         }
1682    } else {
1683         if (sc->amr_submit_command(ac) == EBUSY) {
1684             amr_freeslot(ac);
1685             amr_requeue_ready(ac);
1686         }
1687    }
1688
1689     return (0);
1690 }
1691
1692 static void
1693 amr_unmapcmd(struct amr_command *ac)
1694 {
1695     int                 flag;
1696
1697     debug_called(3);
1698
1699     /* if the command involved data at all and was mapped */
1700     if (ac->ac_flags & AMR_CMD_MAPPED) {
1701
1702         if (ac->ac_data != NULL) {
1703
1704             flag = 0;
1705             if (ac->ac_flags & AMR_CMD_DATAIN)
1706                 flag |= BUS_DMASYNC_POSTREAD;
1707             if (ac->ac_flags & AMR_CMD_DATAOUT)
1708                 flag |= BUS_DMASYNC_POSTWRITE;
1709
1710             bus_dmamap_sync(ac->ac_tag, ac->ac_datamap, flag);
1711             bus_dmamap_unload(ac->ac_tag, ac->ac_datamap);
1712         }
1713
1714         ac->ac_flags &= ~AMR_CMD_MAPPED;
1715     }
1716 }
1717
1718 static void
1719 amr_abort_load(struct amr_command *ac)
1720 {
1721     ac_qhead_t head;
1722     struct amr_softc *sc = ac->ac_sc;
1723
1724     KKASSERT(lockstatus(&sc->amr_list_lock, curthread) != 0);
1725
1726     ac->ac_status = AMR_STATUS_ABORTED;
1727     amr_init_qhead(&head);
1728     amr_enqueue_completed(ac, &head);
1729
1730     lockmgr(&sc->amr_list_lock, LK_RELEASE);
1731     amr_complete(sc, &head);
1732     lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
1733 }
1734
1735 /********************************************************************************
1736  * Take a command and give it to the controller, returns 0 if successful, or
1737  * EBUSY if the command should be retried later.
1738  */
1739 static int
1740 amr_start(struct amr_command *ac)
1741 {
1742     struct amr_softc *sc;
1743     int error = 0;
1744     int slot;
1745
1746     debug_called(3);
1747
1748     /* mark command as busy so that polling consumer can tell */
1749     sc = ac->ac_sc;
1750     ac->ac_flags |= AMR_CMD_BUSY;
1751
1752     /* get a command slot (freed in amr_done) */
1753     slot = ac->ac_slot;
1754     if (sc->amr_busycmd[slot] != NULL)
1755         panic("amr: slot %d busy?", slot);
1756     sc->amr_busycmd[slot] = ac;
1757     atomic_add_int(&sc->amr_busyslots, 1);
1758
1759     /* Now we have a slot, we can map the command (unmapped in amr_complete). */
1760     if ((error = amr_mapcmd(ac)) == ENOMEM) {
1761         /*
1762          * Memroy resources are short, so free the slot and let this be tried
1763          * later.
1764          */
1765         amr_freeslot(ac);
1766     }
1767
1768     return (error);
1769 }
1770
1771 /********************************************************************************
1772  * Extract one or more completed commands from the controller (sc)
1773  *
1774  * Returns nonzero if any commands on the work queue were marked as completed.
1775  */
1776
1777 int
1778 amr_done(struct amr_softc *sc)
1779 {
1780     ac_qhead_t          head;
1781     struct amr_command  *ac;
1782     struct amr_mailbox  mbox;
1783     int                 i, idx, result;
1784     
1785     debug_called(3);
1786
1787     /* See if there's anything for us to do */
1788     result = 0;
1789     amr_init_qhead(&head);
1790
1791     /* loop collecting completed commands */
1792     for (;;) {
1793         /* poll for a completed command's identifier and status */
1794         if (sc->amr_get_work(sc, &mbox)) {
1795             result = 1;
1796             
1797             /* iterate over completed commands in this result */
1798             for (i = 0; i < mbox.mb_nstatus; i++) {
1799                 /* get pointer to busy command */
1800                 idx = mbox.mb_completed[i] - 1;
1801                 ac = sc->amr_busycmd[idx];
1802
1803                 /* really a busy command? */
1804                 if (ac != NULL) {
1805
1806                     /* pull the command from the busy index */
1807                     amr_freeslot(ac);
1808                 
1809                     /* save status for later use */
1810                     ac->ac_status = mbox.mb_status;
1811                     amr_enqueue_completed(ac, &head);
1812                     debug(3, "completed command with status %x", mbox.mb_status);
1813                 } else {
1814                     device_printf(sc->amr_dev, "bad slot %d completed\n", idx);
1815                 }
1816             }
1817         } else
1818             break;      /* no work */
1819     }
1820
1821     /* handle completion and timeouts */
1822     amr_complete(sc, &head);
1823
1824     return(result);
1825 }
1826
1827 /********************************************************************************
1828  * Do completion processing on done commands on (sc)
1829  */
1830
1831 static void
1832 amr_complete(void *context, ac_qhead_t *head)
1833 {
1834     struct amr_softc    *sc = (struct amr_softc *)context;
1835     struct amr_command  *ac;
1836
1837     debug_called(3);
1838
1839     /* pull completed commands off the queue */
1840     for (;;) {
1841         ac = amr_dequeue_completed(sc, head);
1842         if (ac == NULL)
1843             break;
1844
1845         /* unmap the command's data buffer */
1846         amr_unmapcmd(ac);
1847
1848         /* 
1849          * Is there a completion handler? 
1850          */
1851         if (ac->ac_complete != NULL) {
1852             /* unbusy the command */
1853             ac->ac_flags &= ~AMR_CMD_BUSY;
1854             ac->ac_complete(ac);
1855             
1856             /* 
1857              * Is someone sleeping on this one?
1858              */
1859         } else {
1860             lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
1861             ac->ac_flags &= ~AMR_CMD_BUSY;
1862             if (ac->ac_flags & AMR_CMD_SLEEP) {
1863                 /* unbusy the command */
1864                 wakeup(ac);
1865             }
1866             lockmgr(&sc->amr_list_lock, LK_RELEASE);
1867         }
1868
1869         if(!sc->amr_busyslots) {
1870             wakeup(sc);
1871         }
1872     }
1873
1874     lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
1875     sc->amr_state &= ~AMR_STATE_QUEUE_FRZN;
1876     amr_startio(sc);
1877     lockmgr(&sc->amr_list_lock, LK_RELEASE);
1878 }
1879
1880 /********************************************************************************
1881  ********************************************************************************
1882                                                         Command Buffer Management
1883  ********************************************************************************
1884  ********************************************************************************/
1885
1886 /********************************************************************************
1887  * Get a new command buffer.
1888  *
1889  * This may return NULL in low-memory cases.
1890  *
1891  * If possible, we recycle a command buffer that's been used before.
1892  */
1893 struct amr_command *
1894 amr_alloccmd(struct amr_softc *sc)
1895 {
1896     struct amr_command  *ac;
1897
1898     debug_called(3);
1899
1900     ac = amr_dequeue_free(sc);
1901     if (ac == NULL) {
1902         sc->amr_state |= AMR_STATE_QUEUE_FRZN;
1903         return(NULL);
1904     }
1905
1906     /* clear out significant fields */
1907     ac->ac_status = 0;
1908     bzero(&ac->ac_mailbox, sizeof(struct amr_mailbox));
1909     ac->ac_flags = 0;
1910     ac->ac_bio = NULL;
1911     ac->ac_data = NULL;
1912     ac->ac_complete = NULL;
1913     ac->ac_retries = 0;
1914     ac->ac_tag = NULL;
1915     ac->ac_datamap = NULL;
1916     return(ac);
1917 }
1918
1919 /********************************************************************************
1920  * Release a command buffer for recycling.
1921  */
1922 void
1923 amr_releasecmd(struct amr_command *ac)
1924 {
1925     debug_called(3);
1926
1927     amr_enqueue_free(ac);
1928 }
1929
1930 /********************************************************************************
1931  * Allocate a new command cluster and initialise it.
1932  */
1933 static void
1934 amr_alloccmd_cluster(struct amr_softc *sc)
1935 {
1936     struct amr_command_cluster  *acc;
1937     struct amr_command          *ac;
1938     int                         i, nextslot;
1939
1940     /*
1941      * If we haven't found the real limit yet, let us have a couple of
1942      * commands in order to be able to probe.
1943      */
1944     if (sc->amr_maxio == 0)
1945         sc->amr_maxio = 2;
1946
1947     if (sc->amr_nextslot > sc->amr_maxio)
1948         return;
1949     acc = kmalloc(AMR_CMD_CLUSTERSIZE, M_AMR, M_NOWAIT | M_ZERO);
1950     if (acc != NULL) {
1951         nextslot = sc->amr_nextslot;
1952         lockmgr(&sc->amr_list_lock, LK_EXCLUSIVE);
1953         TAILQ_INSERT_TAIL(&sc->amr_cmd_clusters, acc, acc_link);
1954         lockmgr(&sc->amr_list_lock, LK_RELEASE);
1955         for (i = 0; i < AMR_CMD_CLUSTERCOUNT; i++) {
1956             ac = &acc->acc_command[i];
1957             ac->ac_sc = sc;
1958             ac->ac_slot = nextslot;
1959
1960             /*
1961              * The SG table for each slot is a fixed size and is assumed to
1962              * to hold 64-bit s/g objects when the driver is configured to do
1963              * 64-bit DMA.  32-bit DMA commands still use the same table, but
1964              * cast down to 32-bit objects.
1965              */
1966             if (AMR_IS_SG64(sc)) {
1967                 ac->ac_sgbusaddr = sc->amr_sgbusaddr +
1968                     (ac->ac_slot * AMR_NSEG * sizeof(struct amr_sg64entry));
1969                 ac->ac_sg.sg64 = sc->amr_sg64table + (ac->ac_slot * AMR_NSEG);
1970             } else {
1971                 ac->ac_sgbusaddr = sc->amr_sgbusaddr +
1972                     (ac->ac_slot * AMR_NSEG * sizeof(struct amr_sgentry));
1973                 ac->ac_sg.sg32 = sc->amr_sgtable + (ac->ac_slot * AMR_NSEG);
1974             }
1975
1976             ac->ac_ccb = sc->amr_ccb + ac->ac_slot;
1977             ac->ac_ccb_busaddr = sc->amr_ccb_busaddr +
1978                 (ac->ac_slot * sizeof(union amr_ccb));
1979
1980             if (bus_dmamap_create(sc->amr_buffer_dmat, 0, &ac->ac_dmamap))
1981                 break;
1982             if (AMR_IS_SG64(sc) &&
1983                 (bus_dmamap_create(sc->amr_buffer64_dmat, 0,&ac->ac_dma64map)))
1984                 break;
1985             amr_releasecmd(ac);
1986             if (++nextslot > sc->amr_maxio)
1987                 break;
1988         }
1989         sc->amr_nextslot = nextslot;
1990     }
1991 }
1992
1993 /********************************************************************************
1994  * Free a command cluster
1995  */
1996 static void
1997 amr_freecmd_cluster(struct amr_command_cluster *acc)
1998 {
1999     struct amr_softc    *sc = acc->acc_command[0].ac_sc;
2000     int                 i;
2001
2002     for (i = 0; i < AMR_CMD_CLUSTERCOUNT; i++) {
2003         if (acc->acc_command[i].ac_sc == NULL)
2004             break;
2005         bus_dmamap_destroy(sc->amr_buffer_dmat, acc->acc_command[i].ac_dmamap);
2006         if (AMR_IS_SG64(sc))
2007                 bus_dmamap_destroy(sc->amr_buffer64_dmat, acc->acc_command[i].ac_dma64map);
2008     }
2009     kfree(acc, M_AMR);
2010 }
2011
2012 /********************************************************************************
2013  ********************************************************************************
2014                                                          Interface-specific Shims
2015  ********************************************************************************
2016  ********************************************************************************/
2017
2018 /********************************************************************************
2019  * Tell the controller that the mailbox contains a valid command
2020  */
2021 static int
2022 amr_quartz_submit_command(struct amr_command *ac)
2023 {
2024     struct amr_softc    *sc = ac->ac_sc;
2025     static struct timeval lastfail;
2026     static int          curfail;
2027     int                 i = 0;
2028
2029     lockmgr(&sc->amr_hw_lock, LK_EXCLUSIVE);
2030     while (sc->amr_mailbox->mb_busy && (i++ < 10)) {
2031         DELAY(1);
2032         /* This is a no-op read that flushes pending mailbox updates */
2033         AMR_QGET_ODB(sc);
2034     }
2035     if (sc->amr_mailbox->mb_busy) {
2036         lockmgr(&sc->amr_hw_lock, LK_RELEASE);
2037         if (ac->ac_retries++ > 1000) {
2038             if (ppsratecheck(&lastfail, &curfail, 1))
2039                 device_printf(sc->amr_dev, "Too many retries on command %p.  "
2040                               "Controller is likely dead\n", ac);
2041             ac->ac_retries = 0;
2042         }
2043         return (EBUSY);
2044     }
2045
2046     /*
2047      * Save the slot number so that we can locate this command when complete.
2048      * Note that ident = 0 seems to be special, so we don't use it.
2049      */
2050     ac->ac_mailbox.mb_ident = ac->ac_slot + 1; /* will be coppied into mbox */
2051     bcopy(&ac->ac_mailbox, (void *)(uintptr_t)(volatile void *)sc->amr_mailbox, 14);
2052     sc->amr_mailbox->mb_busy = 1;
2053     sc->amr_mailbox->mb_poll = 0;
2054     sc->amr_mailbox->mb_ack  = 0;
2055     sc->amr_mailbox64->sg64_hi = ac->ac_sg64_hi;
2056     sc->amr_mailbox64->sg64_lo = ac->ac_sg64_lo;
2057
2058     AMR_QPUT_IDB(sc, sc->amr_mailboxphys | AMR_QIDB_SUBMIT);
2059     lockmgr(&sc->amr_hw_lock, LK_RELEASE);
2060     return(0);
2061 }
2062
2063 static int
2064 amr_std_submit_command(struct amr_command *ac)
2065 {
2066     struct amr_softc    *sc = ac->ac_sc;
2067     static struct timeval lastfail;
2068     static int          curfail;
2069
2070     lockmgr(&sc->amr_hw_lock, LK_EXCLUSIVE);
2071     if (AMR_SGET_MBSTAT(sc) & AMR_SMBOX_BUSYFLAG) {
2072         lockmgr(&sc->amr_hw_lock, LK_RELEASE);
2073         if (ac->ac_retries++ > 1000) {
2074             if (ppsratecheck(&lastfail, &curfail, 1))
2075                 device_printf(sc->amr_dev, "Too many retries on command %p.  "
2076                               "Controller is likely dead\n", ac);
2077             ac->ac_retries = 0;
2078         }
2079         return (EBUSY);
2080     }
2081
2082     /*
2083      * Save the slot number so that we can locate this command when complete.
2084      * Note that ident = 0 seems to be special, so we don't use it.
2085      */
2086     ac->ac_mailbox.mb_ident = ac->ac_slot + 1; /* will be coppied into mbox */
2087     bcopy(&ac->ac_mailbox, (void *)(uintptr_t)(volatile void *)sc->amr_mailbox, 14);
2088     sc->amr_mailbox->mb_busy = 1;
2089     sc->amr_mailbox->mb_poll = 0;
2090     sc->amr_mailbox->mb_ack  = 0;
2091
2092     AMR_SPOST_COMMAND(sc);
2093     lockmgr(&sc->amr_hw_lock, LK_RELEASE);
2094     return(0);
2095 }
2096
2097 /********************************************************************************
2098  * Claim any work that the controller has completed; acknowledge completion,
2099  * save details of the completion in (mbsave)
2100  */
2101 static int
2102 amr_quartz_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave)
2103 {
2104     int         worked, i;
2105     u_int32_t   outd;
2106     u_int8_t    nstatus;
2107     u_int8_t    completed[46];
2108
2109     debug_called(3);
2110
2111     worked = 0;
2112
2113     /* work waiting for us? */
2114     if ((outd = AMR_QGET_ODB(sc)) == AMR_QODB_READY) {
2115
2116         /* acknowledge interrupt */
2117         AMR_QPUT_ODB(sc, AMR_QODB_READY);
2118
2119         while ((nstatus = sc->amr_mailbox->mb_nstatus) == 0xff)
2120             DELAY(1);
2121         sc->amr_mailbox->mb_nstatus = 0xff;
2122
2123         /* wait until fw wrote out all completions */
2124         for (i = 0; i < nstatus; i++) {
2125             while ((completed[i] = sc->amr_mailbox->mb_completed[i]) == 0xff)
2126                 DELAY(1);
2127             sc->amr_mailbox->mb_completed[i] = 0xff;
2128         }
2129
2130         /* Save information for later processing */
2131         mbsave->mb_nstatus = nstatus;
2132         mbsave->mb_status = sc->amr_mailbox->mb_status;
2133         sc->amr_mailbox->mb_status = 0xff;
2134
2135         for (i = 0; i < nstatus; i++)
2136             mbsave->mb_completed[i] = completed[i];
2137
2138         /* acknowledge that we have the commands */
2139         AMR_QPUT_IDB(sc, AMR_QIDB_ACK);
2140
2141 #if 0
2142 #ifndef AMR_QUARTZ_GOFASTER
2143         /*
2144          * This waits for the controller to notice that we've taken the
2145          * command from it.  It's very inefficient, and we shouldn't do it,
2146          * but if we remove this code, we stop completing commands under
2147          * load.
2148          *
2149          * Peter J says we shouldn't do this.  The documentation says we
2150          * should.  Who is right?
2151          */
2152         while(AMR_QGET_IDB(sc) & AMR_QIDB_ACK)
2153             ;                           /* XXX aiee! what if it dies? */
2154 #endif
2155 #endif
2156
2157         worked = 1;                     /* got some work */
2158     }
2159
2160     return(worked);
2161 }
2162
2163 static int
2164 amr_std_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave)
2165 {
2166     int         worked;
2167     u_int8_t    istat;
2168
2169     debug_called(3);
2170
2171     worked = 0;
2172
2173     /* check for valid interrupt status */
2174     istat = AMR_SGET_ISTAT(sc);
2175     if ((istat & AMR_SINTR_VALID) != 0) {
2176         AMR_SPUT_ISTAT(sc, istat);      /* ack interrupt status */
2177
2178         /* save mailbox, which contains a list of completed commands */
2179         bcopy((void *)(uintptr_t)(volatile void *)sc->amr_mailbox, mbsave, sizeof(*mbsave));
2180
2181         AMR_SACK_INTERRUPT(sc);         /* acknowledge we have the mailbox */
2182         worked = 1;
2183     }
2184
2185     return(worked);
2186 }
2187
2188 /********************************************************************************
2189  * Notify the controller of the mailbox location.
2190  */
2191 static void
2192 amr_std_attach_mailbox(struct amr_softc *sc)
2193 {
2194
2195     /* program the mailbox physical address */
2196     AMR_SBYTE_SET(sc, AMR_SMBOX_0, sc->amr_mailboxphys         & 0xff);
2197     AMR_SBYTE_SET(sc, AMR_SMBOX_1, (sc->amr_mailboxphys >>  8) & 0xff);
2198     AMR_SBYTE_SET(sc, AMR_SMBOX_2, (sc->amr_mailboxphys >> 16) & 0xff);
2199     AMR_SBYTE_SET(sc, AMR_SMBOX_3, (sc->amr_mailboxphys >> 24) & 0xff);
2200     AMR_SBYTE_SET(sc, AMR_SMBOX_ENABLE, AMR_SMBOX_ADDR);
2201
2202     /* clear any outstanding interrupt and enable interrupts proper */
2203     AMR_SACK_INTERRUPT(sc);
2204     AMR_SENABLE_INTR(sc);
2205 }
2206
2207 #ifdef AMR_BOARD_INIT
2208 /********************************************************************************
2209  * Initialise the controller
2210  */
2211 static int
2212 amr_quartz_init(struct amr_softc *sc)
2213 {
2214     int         status, ostatus;
2215
2216     device_printf(sc->amr_dev, "initial init status %x\n", AMR_QGET_INITSTATUS(sc));
2217
2218     AMR_QRESET(sc);
2219
2220     ostatus = 0xff;
2221     while ((status = AMR_QGET_INITSTATUS(sc)) != AMR_QINIT_DONE) {
2222         if (status != ostatus) {
2223             device_printf(sc->amr_dev, "(%x) %s\n", status, amr_describe_code(amr_table_qinit, status));
2224             ostatus = status;
2225         }
2226         switch (status) {
2227         case AMR_QINIT_NOMEM:
2228             return(ENOMEM);
2229
2230         case AMR_QINIT_SCAN:
2231             /* XXX we could print channel/target here */
2232             break;
2233         }
2234     }
2235     return(0);
2236 }
2237
2238 static int
2239 amr_std_init(struct amr_softc *sc)
2240 {
2241     int         status, ostatus;
2242
2243     device_printf(sc->amr_dev, "initial init status %x\n", AMR_SGET_INITSTATUS(sc));
2244
2245     AMR_SRESET(sc);
2246  
2247     ostatus = 0xff;
2248     while ((status = AMR_SGET_INITSTATUS(sc)) != AMR_SINIT_DONE) {
2249         if (status != ostatus) {
2250             device_printf(sc->amr_dev, "(%x) %s\n", status, amr_describe_code(amr_table_sinit, status));
2251             ostatus = status;
2252         }
2253         switch (status) {
2254         case AMR_SINIT_NOMEM:
2255             return(ENOMEM);
2256
2257         case AMR_SINIT_INPROG:
2258             /* XXX we could print channel/target here? */
2259             break;
2260         }
2261     }
2262     return(0);
2263 }
2264 #endif
2265
2266 /********************************************************************************
2267  ********************************************************************************
2268                                                                         Debugging
2269  ********************************************************************************
2270  ********************************************************************************/
2271
2272 /********************************************************************************
2273  * Identify the controller and print some information about it.
2274  */
2275 static void
2276 amr_describe_controller(struct amr_softc *sc)
2277 {
2278     struct amr_prodinfo *ap;
2279     struct amr_enquiry  *ae;
2280     char                *prod;
2281     int                 status;
2282
2283     /*
2284      * Try to get 40LD product info, which tells us what the card is labelled as.
2285      */
2286     if ((ap = amr_enquiry(sc, 2048, AMR_CMD_CONFIG, AMR_CONFIG_PRODUCT_INFO, 0, &status)) != NULL) {
2287         device_printf(sc->amr_dev, "<LSILogic %.80s> Firmware %.16s, BIOS %.16s, %dMB RAM\n",
2288                       ap->ap_product, ap->ap_firmware, ap->ap_bios,
2289                       ap->ap_memsize);
2290
2291         kfree(ap, M_AMR);
2292         return;
2293     }
2294
2295     /*
2296      * Try 8LD extended ENQUIRY to get controller signature, and use lookup table.
2297      */
2298     if ((ae = (struct amr_enquiry *)amr_enquiry(sc, 2048, AMR_CMD_EXT_ENQUIRY2, 0, 0, &status)) != NULL) {
2299         prod = amr_describe_code(amr_table_adaptertype, ae->ae_signature);
2300
2301     } else if ((ae = (struct amr_enquiry *)amr_enquiry(sc, 2048, AMR_CMD_ENQUIRY, 0, 0, &status)) != NULL) {
2302
2303         /*
2304          * Try to work it out based on the PCI signatures.
2305          */
2306         switch (pci_get_device(sc->amr_dev)) {
2307         case 0x9010:
2308             prod = "Series 428";
2309             break;
2310         case 0x9060:
2311             prod = "Series 434";
2312             break;
2313         default:
2314             prod = "unknown controller";
2315             break;
2316         }
2317     } else {
2318         device_printf(sc->amr_dev, "<unsupported controller>\n");
2319         return;
2320     }
2321
2322     /*
2323      * HP NetRaid controllers have a special encoding of the firmware and
2324      * BIOS versions. The AMI version seems to have it as strings whereas
2325      * the HP version does it with a leading uppercase character and two
2326      * binary numbers.
2327      */
2328      
2329     if(ae->ae_adapter.aa_firmware[2] >= 'A' &&
2330        ae->ae_adapter.aa_firmware[2] <= 'Z' &&
2331        ae->ae_adapter.aa_firmware[1] <  ' ' &&
2332        ae->ae_adapter.aa_firmware[0] <  ' ' &&
2333        ae->ae_adapter.aa_bios[2] >= 'A'     &&
2334        ae->ae_adapter.aa_bios[2] <= 'Z'     &&
2335        ae->ae_adapter.aa_bios[1] <  ' '     &&
2336        ae->ae_adapter.aa_bios[0] <  ' ') {
2337
2338         /* this looks like we have an HP NetRaid version of the MegaRaid */
2339
2340         if(ae->ae_signature == AMR_SIG_438) {
2341                 /* the AMI 438 is a NetRaid 3si in HP-land */
2342                 prod = "HP NetRaid 3si";
2343         }
2344         
2345         device_printf(sc->amr_dev, "<%s> Firmware %c.%02d.%02d, BIOS %c.%02d.%02d, %dMB RAM\n",
2346                       prod, ae->ae_adapter.aa_firmware[2],
2347                       ae->ae_adapter.aa_firmware[1],
2348                       ae->ae_adapter.aa_firmware[0],
2349                       ae->ae_adapter.aa_bios[2],
2350                       ae->ae_adapter.aa_bios[1],
2351                       ae->ae_adapter.aa_bios[0],
2352                       ae->ae_adapter.aa_memorysize);            
2353     } else {
2354         device_printf(sc->amr_dev, "<%s> Firmware %.4s, BIOS %.4s, %dMB RAM\n", 
2355                       prod, ae->ae_adapter.aa_firmware, ae->ae_adapter.aa_bios,
2356                       ae->ae_adapter.aa_memorysize);
2357     }           
2358     kfree(ae, M_AMR);
2359 }
2360
2361 int
2362 amr_dump_blocks(struct amr_softc *sc, int unit, u_int32_t lba, void *data, int blks)
2363 {
2364     struct amr_command  *ac;
2365     int                 error = EIO;
2366
2367     debug_called(1);
2368
2369     sc->amr_state |= AMR_STATE_INTEN;
2370
2371     /* get ourselves a command buffer */
2372     if ((ac = amr_alloccmd(sc)) == NULL)
2373         goto out;
2374     /* set command flags */
2375     ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT;
2376     
2377     /* point the command at our data */
2378     ac->ac_data = data;
2379     ac->ac_length = blks * AMR_BLKSIZE;
2380     
2381     /* build the command proper */
2382     ac->ac_mailbox.mb_command   = AMR_CMD_LWRITE;
2383     ac->ac_mailbox.mb_blkcount  = blks;
2384     ac->ac_mailbox.mb_lba       = lba;
2385     ac->ac_mailbox.mb_drive     = unit;
2386
2387     /* can't assume that interrupts are going to work here, so play it safe */
2388     if (sc->amr_poll_command(ac))
2389         goto out;
2390     error = ac->ac_status;
2391     
2392  out:
2393     if (ac != NULL)
2394         amr_releasecmd(ac);
2395
2396     sc->amr_state &= ~AMR_STATE_INTEN;
2397     return (error);
2398 }
2399
2400
2401
2402 #ifdef AMR_DEBUG
2403 /********************************************************************************
2404  * Print the command (ac) in human-readable format
2405  */
2406 #if 0
2407 static void
2408 amr_printcommand(struct amr_command *ac)
2409 {
2410     struct amr_softc    *sc = ac->ac_sc;
2411     struct amr_sgentry  *sg;
2412     int                 i;
2413     
2414     device_printf(sc->amr_dev, "cmd %x  ident %d  drive %d\n",
2415                   ac->ac_mailbox.mb_command, ac->ac_mailbox.mb_ident, ac->ac_mailbox.mb_drive);
2416     device_printf(sc->amr_dev, "blkcount %d  lba %d\n", 
2417                   ac->ac_mailbox.mb_blkcount, ac->ac_mailbox.mb_lba);
2418     device_printf(sc->amr_dev, "virtaddr %p  length %lu\n", ac->ac_data, (unsigned long)ac->ac_length);
2419     device_printf(sc->amr_dev, "sg physaddr %08x  nsg %d\n",
2420                   ac->ac_mailbox.mb_physaddr, ac->ac_mailbox.mb_nsgelem);
2421     device_printf(sc->amr_dev, "ccb %p  bio %p\n", ac->ac_ccb_data, ac->ac_bio);
2422
2423     /* get base address of s/g table */
2424     sg = sc->amr_sgtable + (ac->ac_slot * AMR_NSEG);
2425     for (i = 0; i < ac->ac_mailbox.mb_nsgelem; i++, sg++)
2426         device_printf(sc->amr_dev, "  %x/%d\n", sg->sg_addr, sg->sg_count);
2427 }
2428 #endif
2429 #endif