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