xref: /freebsd/sys/dev/ciss/ciss.c (revision aa339f1d5df9e38f36a34eb522355c4eebcae6c4)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright (c) 2001 Michael Smith
5  * Copyright (c) 2004 Paul Saab
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 
30 /*
31  * Common Interface for SCSI-3 Support driver.
32  *
33  * CISS claims to provide a common interface between a generic SCSI
34  * transport and an intelligent host adapter.
35  *
36  * This driver supports CISS as defined in the document "CISS Command
37  * Interface for SCSI-3 Support Open Specification", Version 1.04,
38  * Valence Number 1, dated 20001127, produced by Compaq Computer
39  * Corporation.  This document appears to be a hastily and somewhat
40  * arbitrarlily cut-down version of a larger (and probably even more
41  * chaotic and inconsistent) Compaq internal document.  Various
42  * details were also gleaned from Compaq's "cciss" driver for Linux.
43  *
44  * We provide a shim layer between the CISS interface and CAM,
45  * offloading most of the queueing and being-a-disk chores onto CAM.
46  * Entry to the driver is via the PCI bus attachment (ciss_probe,
47  * ciss_attach, etc) and via the CAM interface (ciss_cam_action,
48  * ciss_cam_poll).  The Compaq CISS adapters are, however, poor SCSI
49  * citizens and we have to fake up some responses to get reasonable
50  * behaviour out of them.  In addition, the CISS command set is by no
51  * means adequate to support the functionality of a RAID controller,
52  * and thus the supported Compaq adapters utilise portions of the
53  * control protocol from earlier Compaq adapter families.
54  *
55  * Note that we only support the "simple" transport layer over PCI.
56  * This interface (ab)uses the I2O register set (specifically the post
57  * queues) to exchange commands with the adapter.  Other interfaces
58  * are available, but we aren't supposed to know about them, and it is
59  * dubious whether they would provide major performance improvements
60  * except under extreme load.
61  *
62  * Currently the only supported CISS adapters are the Compaq Smart
63  * Array 5* series (5300, 5i, 532).  Even with only three adapters,
64  * Compaq still manage to have interface variations.
65  *
66  *
67  * Thanks must go to Fred Harris and Darryl DeVinney at Compaq, as
68  * well as Paul Saab at Yahoo! for their assistance in making this
69  * driver happen.
70  *
71  * More thanks must go to John Cagle at HP for the countless hours
72  * spent making this driver "work" with the MSA* series storage
73  * enclosures.  Without his help (and nagging), this driver could not
74  * be used with these enclosures.
75  */
76 
77 #include <sys/param.h>
78 #include <sys/systm.h>
79 #include <sys/malloc.h>
80 #include <sys/kernel.h>
81 #include <sys/bus.h>
82 #include <sys/conf.h>
83 #include <sys/stat.h>
84 #include <sys/kthread.h>
85 #include <sys/queue.h>
86 #include <sys/sysctl.h>
87 
88 #include <cam/cam.h>
89 #include <cam/cam_ccb.h>
90 #include <cam/cam_periph.h>
91 #include <cam/cam_sim.h>
92 #include <cam/cam_xpt_sim.h>
93 #include <cam/scsi/scsi_all.h>
94 #include <cam/scsi/scsi_message.h>
95 
96 #include <machine/bus.h>
97 #include <machine/endian.h>
98 #include <machine/resource.h>
99 #include <sys/rman.h>
100 
101 #include <dev/pci/pcireg.h>
102 #include <dev/pci/pcivar.h>
103 
104 #include <dev/ciss/cissreg.h>
105 #include <dev/ciss/cissio.h>
106 #include <dev/ciss/cissvar.h>
107 
108 #ifdef CISS_DEBUG
109 #include "opt_ddb.h"
110 #endif
111 
112 static MALLOC_DEFINE(CISS_MALLOC_CLASS, "ciss_data",
113     "ciss internal data buffers");
114 
115 /* pci interface */
116 static int	ciss_lookup(device_t dev);
117 static int	ciss_probe(device_t dev);
118 static int	ciss_attach(device_t dev);
119 static int	ciss_detach(device_t dev);
120 static int	ciss_shutdown(device_t dev);
121 
122 /* (de)initialisation functions, control wrappers */
123 static int	ciss_init_pci(struct ciss_softc *sc);
124 static int	ciss_setup_msix(struct ciss_softc *sc);
125 static int	ciss_init_perf(struct ciss_softc *sc);
126 static int	ciss_wait_adapter(struct ciss_softc *sc);
127 static int	ciss_flush_adapter(struct ciss_softc *sc);
128 static int	ciss_init_requests(struct ciss_softc *sc);
129 static void	ciss_command_map_helper(void *arg, bus_dma_segment_t *segs,
130 					int nseg, int error);
131 static int	ciss_identify_adapter(struct ciss_softc *sc);
132 static int	ciss_init_logical(struct ciss_softc *sc);
133 static int	ciss_init_physical(struct ciss_softc *sc);
134 static int	ciss_filter_physical(struct ciss_softc *sc, struct ciss_lun_report *cll);
135 static int	ciss_identify_logical(struct ciss_softc *sc, struct ciss_ldrive *ld);
136 static int	ciss_get_ldrive_status(struct ciss_softc *sc,  struct ciss_ldrive *ld);
137 static int	ciss_update_config(struct ciss_softc *sc);
138 static int	ciss_accept_media(struct ciss_softc *sc, struct ciss_ldrive *ld);
139 static void	ciss_init_sysctl(struct ciss_softc *sc);
140 static void	ciss_soft_reset(struct ciss_softc *sc);
141 static void	ciss_free(struct ciss_softc *sc);
142 static void	ciss_spawn_notify_thread(struct ciss_softc *sc);
143 static void	ciss_kill_notify_thread(struct ciss_softc *sc);
144 
145 /* request submission/completion */
146 static int	ciss_start(struct ciss_request *cr);
147 static void	ciss_done(struct ciss_softc *sc, cr_qhead_t *qh);
148 static void	ciss_perf_done(struct ciss_softc *sc, cr_qhead_t *qh);
149 static void	ciss_intr(void *arg);
150 static void	ciss_perf_intr(void *arg);
151 static void	ciss_perf_msi_intr(void *arg);
152 static void	ciss_complete(struct ciss_softc *sc, cr_qhead_t *qh);
153 static int	_ciss_report_request(struct ciss_request *cr, int *command_status, int *scsi_status, const char *func);
154 static int	ciss_synch_request(struct ciss_request *cr, int timeout);
155 static int	ciss_poll_request(struct ciss_request *cr, int timeout);
156 static int	ciss_wait_request(struct ciss_request *cr, int timeout);
157 #if 0
158 static int	ciss_abort_request(struct ciss_request *cr);
159 #endif
160 
161 /* request queueing */
162 static int	ciss_get_request(struct ciss_softc *sc, struct ciss_request **crp);
163 static void	ciss_preen_command(struct ciss_request *cr);
164 static void 	ciss_release_request(struct ciss_request *cr);
165 
166 /* request helpers */
167 static int	ciss_get_bmic_request(struct ciss_softc *sc, struct ciss_request **crp,
168 				      int opcode, void **bufp, size_t bufsize);
169 static int	ciss_user_command(struct ciss_softc *sc, IOCTL_Command_struct *ioc);
170 
171 /* DMA map/unmap */
172 static int	ciss_map_request(struct ciss_request *cr);
173 static void	ciss_request_map_helper(void *arg, bus_dma_segment_t *segs,
174 					int nseg, int error);
175 static void	ciss_unmap_request(struct ciss_request *cr);
176 
177 /* CAM interface */
178 static int	ciss_cam_init(struct ciss_softc *sc);
179 static void	ciss_cam_rescan_target(struct ciss_softc *sc,
180 				       int bus, int target);
181 static void	ciss_cam_action(struct cam_sim *sim, union ccb *ccb);
182 static int	ciss_cam_action_io(struct cam_sim *sim, struct ccb_scsiio *csio);
183 static int	ciss_cam_emulate(struct ciss_softc *sc, struct ccb_scsiio *csio);
184 static void	ciss_cam_poll(struct cam_sim *sim);
185 static void	ciss_cam_complete(struct ciss_request *cr);
186 static void	ciss_cam_complete_fixup(struct ciss_softc *sc, struct ccb_scsiio *csio);
187 static int	ciss_name_device(struct ciss_softc *sc, int bus, int target);
188 
189 /* periodic status monitoring */
190 static void	ciss_periodic(void *arg);
191 static void	ciss_nop_complete(struct ciss_request *cr);
192 static void	ciss_disable_adapter(struct ciss_softc *sc);
193 static void	ciss_notify_event(struct ciss_softc *sc);
194 static void	ciss_notify_complete(struct ciss_request *cr);
195 static int	ciss_notify_abort(struct ciss_softc *sc);
196 static int	ciss_notify_abort_bmic(struct ciss_softc *sc);
197 static void	ciss_notify_hotplug(struct ciss_softc *sc, struct ciss_notify *cn);
198 static void	ciss_notify_logical(struct ciss_softc *sc, struct ciss_notify *cn);
199 static void	ciss_notify_physical(struct ciss_softc *sc, struct ciss_notify *cn);
200 
201 /* debugging output */
202 #ifdef DDB
203 static void	ciss_print_request(struct ciss_request *cr);
204 #endif
205 static void	ciss_print_ldrive(struct ciss_softc *sc, struct ciss_ldrive *ld);
206 static const char *ciss_name_ldrive_status(int status);
207 static int	ciss_decode_ldrive_status(int status);
208 static const char *ciss_name_ldrive_org(int org);
209 static const char *ciss_name_command_status(int status);
210 
211 /*
212  * PCI bus interface.
213  */
214 static device_method_t ciss_methods[] = {
215     /* Device interface */
216     DEVMETHOD(device_probe,	ciss_probe),
217     DEVMETHOD(device_attach,	ciss_attach),
218     DEVMETHOD(device_detach,	ciss_detach),
219     DEVMETHOD(device_shutdown,	ciss_shutdown),
220     { 0, 0 }
221 };
222 
223 static driver_t ciss_pci_driver = {
224     "ciss",
225     ciss_methods,
226     sizeof(struct ciss_softc)
227 };
228 
229 /*
230  * Control device interface.
231  */
232 static d_open_t		ciss_open;
233 static d_close_t	ciss_close;
234 static d_ioctl_t	ciss_ioctl;
235 
236 static struct cdevsw ciss_cdevsw = {
237 	.d_version =	D_VERSION,
238 	.d_flags =	0,
239 	.d_open =	ciss_open,
240 	.d_close =	ciss_close,
241 	.d_ioctl =	ciss_ioctl,
242 	.d_name =	"ciss",
243 };
244 
245 /*
246  * This tunable can be set at boot time and controls whether physical devices
247  * that are marked hidden by the firmware should be exposed anyways.
248  */
249 static unsigned int ciss_expose_hidden_physical = 0;
250 TUNABLE_INT("hw.ciss.expose_hidden_physical", &ciss_expose_hidden_physical);
251 
252 static unsigned int ciss_nop_message_heartbeat = 0;
253 TUNABLE_INT("hw.ciss.nop_message_heartbeat", &ciss_nop_message_heartbeat);
254 
255 /*
256  * This tunable can force a particular transport to be used:
257  * <= 0 : use default
258  *    1 : force simple
259  *    2 : force performant
260  */
261 static int ciss_force_transport = 0;
262 TUNABLE_INT("hw.ciss.force_transport", &ciss_force_transport);
263 
264 /*
265  * This tunable can force a particular interrupt delivery method to be used:
266  * <= 0 : use default
267  *    1 : force INTx
268  *    2 : force MSIX
269  */
270 static int ciss_force_interrupt = 0;
271 TUNABLE_INT("hw.ciss.force_interrupt", &ciss_force_interrupt);
272 
273 /************************************************************************
274  * CISS adapters amazingly don't have a defined programming interface
275  * value.  (One could say some very despairing things about PCI and
276  * people just not getting the general idea.)  So we are forced to
277  * stick with matching against subvendor/subdevice, and thus have to
278  * be updated for every new CISS adapter that appears.
279  */
280 #define CISS_BOARD_UNKNOWN	0
281 #define CISS_BOARD_SA5		1
282 #define CISS_BOARD_SA5B		2
283 #define CISS_BOARD_NOMSI	(1<<4)
284 #define CISS_BOARD_SIMPLE       (1<<5)
285 
286 static struct
287 {
288     u_int16_t	subvendor;
289     u_int16_t	subdevice;
290     int		flags;
291     char	*desc;
292 } ciss_vendor_data[] = {
293     { 0x0e11, 0x4070, CISS_BOARD_SA5|CISS_BOARD_NOMSI|CISS_BOARD_SIMPLE,
294                                                         "Compaq Smart Array 5300" },
295     { 0x0e11, 0x4080, CISS_BOARD_SA5B|CISS_BOARD_NOMSI,	"Compaq Smart Array 5i" },
296     { 0x0e11, 0x4082, CISS_BOARD_SA5B|CISS_BOARD_NOMSI,	"Compaq Smart Array 532" },
297     { 0x0e11, 0x4083, CISS_BOARD_SA5B|CISS_BOARD_NOMSI,	"HP Smart Array 5312" },
298     { 0x0e11, 0x4091, CISS_BOARD_SA5,	"HP Smart Array 6i" },
299     { 0x0e11, 0x409A, CISS_BOARD_SA5,	"HP Smart Array 641" },
300     { 0x0e11, 0x409B, CISS_BOARD_SA5,	"HP Smart Array 642" },
301     { 0x0e11, 0x409C, CISS_BOARD_SA5,	"HP Smart Array 6400" },
302     { 0x0e11, 0x409D, CISS_BOARD_SA5,	"HP Smart Array 6400 EM" },
303     { 0x103C, 0x3211, CISS_BOARD_SA5,	"HP Smart Array E200i" },
304     { 0x103C, 0x3212, CISS_BOARD_SA5,	"HP Smart Array E200" },
305     { 0x103C, 0x3213, CISS_BOARD_SA5,	"HP Smart Array E200i" },
306     { 0x103C, 0x3214, CISS_BOARD_SA5,	"HP Smart Array E200i" },
307     { 0x103C, 0x3215, CISS_BOARD_SA5,	"HP Smart Array E200i" },
308     { 0x103C, 0x3220, CISS_BOARD_SA5,	"HP Smart Array" },
309     { 0x103C, 0x3222, CISS_BOARD_SA5,	"HP Smart Array" },
310     { 0x103C, 0x3223, CISS_BOARD_SA5,	"HP Smart Array P800" },
311     { 0x103C, 0x3225, CISS_BOARD_SA5,	"HP Smart Array P600" },
312     { 0x103C, 0x3230, CISS_BOARD_SA5,	"HP Smart Array" },
313     { 0x103C, 0x3231, CISS_BOARD_SA5,	"HP Smart Array" },
314     { 0x103C, 0x3232, CISS_BOARD_SA5,	"HP Smart Array" },
315     { 0x103C, 0x3233, CISS_BOARD_SA5,	"HP Smart Array" },
316     { 0x103C, 0x3234, CISS_BOARD_SA5,	"HP Smart Array P400" },
317     { 0x103C, 0x3235, CISS_BOARD_SA5,	"HP Smart Array P400i" },
318     { 0x103C, 0x3236, CISS_BOARD_SA5,	"HP Smart Array" },
319     { 0x103C, 0x3237, CISS_BOARD_SA5,	"HP Smart Array E500" },
320     { 0x103C, 0x3238, CISS_BOARD_SA5,	"HP Smart Array" },
321     { 0x103C, 0x3239, CISS_BOARD_SA5,	"HP Smart Array" },
322     { 0x103C, 0x323A, CISS_BOARD_SA5,	"HP Smart Array" },
323     { 0x103C, 0x323B, CISS_BOARD_SA5,	"HP Smart Array" },
324     { 0x103C, 0x323C, CISS_BOARD_SA5,	"HP Smart Array" },
325     { 0x103C, 0x323D, CISS_BOARD_SA5,	"HP Smart Array P700m" },
326     { 0x103C, 0x3241, CISS_BOARD_SA5,	"HP Smart Array P212" },
327     { 0x103C, 0x3243, CISS_BOARD_SA5,	"HP Smart Array P410" },
328     { 0x103C, 0x3245, CISS_BOARD_SA5,	"HP Smart Array P410i" },
329     { 0x103C, 0x3247, CISS_BOARD_SA5,	"HP Smart Array P411" },
330     { 0x103C, 0x3249, CISS_BOARD_SA5,	"HP Smart Array P812" },
331     { 0x103C, 0x324A, CISS_BOARD_SA5,	"HP Smart Array P712m" },
332     { 0x103C, 0x324B, CISS_BOARD_SA5,	"HP Smart Array" },
333     { 0x103C, 0x3350, CISS_BOARD_SA5,   "HP Smart Array P222" },
334     { 0x103C, 0x3351, CISS_BOARD_SA5,   "HP Smart Array P420" },
335     { 0x103C, 0x3352, CISS_BOARD_SA5,   "HP Smart Array P421" },
336     { 0x103C, 0x3353, CISS_BOARD_SA5,   "HP Smart Array P822" },
337     { 0x103C, 0x3354, CISS_BOARD_SA5,   "HP Smart Array P420i" },
338     { 0x103C, 0x3355, CISS_BOARD_SA5,   "HP Smart Array P220i" },
339     { 0x103C, 0x3356, CISS_BOARD_SA5,   "HP Smart Array P721m" },
340     { 0x103C, 0x1920, CISS_BOARD_SA5,   "HP Smart Array P430i" },
341     { 0x103C, 0x1921, CISS_BOARD_SA5,   "HP Smart Array P830i" },
342     { 0x103C, 0x1922, CISS_BOARD_SA5,   "HP Smart Array P430" },
343     { 0x103C, 0x1923, CISS_BOARD_SA5,   "HP Smart Array P431" },
344     { 0x103C, 0x1924, CISS_BOARD_SA5,   "HP Smart Array P830" },
345     { 0x103C, 0x1926, CISS_BOARD_SA5,   "HP Smart Array P731m" },
346     { 0x103C, 0x1928, CISS_BOARD_SA5,   "HP Smart Array P230i" },
347     { 0x103C, 0x1929, CISS_BOARD_SA5,   "HP Smart Array P530" },
348     { 0x103C, 0x192A, CISS_BOARD_SA5,   "HP Smart Array P531" },
349     { 0x103C, 0x21BD, CISS_BOARD_SA5,   "HP Smart Array P244br" },
350     { 0x103C, 0x21BE, CISS_BOARD_SA5,   "HP Smart Array P741m" },
351     { 0x103C, 0x21BF, CISS_BOARD_SA5,   "HP Smart Array H240ar" },
352     { 0x103C, 0x21C0, CISS_BOARD_SA5,   "HP Smart Array P440ar" },
353     { 0x103C, 0x21C1, CISS_BOARD_SA5,   "HP Smart Array P840ar" },
354     { 0x103C, 0x21C2, CISS_BOARD_SA5,   "HP Smart Array P440" },
355     { 0x103C, 0x21C3, CISS_BOARD_SA5,   "HP Smart Array P441" },
356     { 0x103C, 0x21C5, CISS_BOARD_SA5,   "HP Smart Array P841" },
357     { 0x103C, 0x21C6, CISS_BOARD_SA5,   "HP Smart Array H244br" },
358     { 0x103C, 0x21C7, CISS_BOARD_SA5,   "HP Smart Array H240" },
359     { 0x103C, 0x21C8, CISS_BOARD_SA5,   "HP Smart Array H241" },
360     { 0x103C, 0x21CA, CISS_BOARD_SA5,   "HP Smart Array P246br" },
361     { 0x103C, 0x21CB, CISS_BOARD_SA5,   "HP Smart Array P840" },
362     { 0x103C, 0x21CC, CISS_BOARD_SA5,   "HP Smart Array P542d" },
363     { 0x103C, 0x21CD, CISS_BOARD_SA5,   "HP Smart Array P240nr" },
364     { 0x103C, 0x21CE, CISS_BOARD_SA5,   "HP Smart Array H240nr" },
365     { 0, 0, 0, NULL }
366 };
367 
368 DRIVER_MODULE(ciss, pci, ciss_pci_driver, 0, 0);
369 MODULE_PNP_INFO("U16:vendor;U16:device;", pci, ciss, ciss_vendor_data,
370     nitems(ciss_vendor_data) - 1);
371 MODULE_DEPEND(ciss, cam, 1, 1, 1);
372 MODULE_DEPEND(ciss, pci, 1, 1, 1);
373 
374 /************************************************************************
375  * Find a match for the device in our list of known adapters.
376  */
377 static int
378 ciss_lookup(device_t dev)
379 {
380     int 	i;
381 
382     for (i = 0; ciss_vendor_data[i].desc != NULL; i++)
383 	if ((pci_get_subvendor(dev) == ciss_vendor_data[i].subvendor) &&
384 	    (pci_get_subdevice(dev) == ciss_vendor_data[i].subdevice)) {
385 	    return(i);
386 	}
387     return(-1);
388 }
389 
390 /************************************************************************
391  * Match a known CISS adapter.
392  */
393 static int
394 ciss_probe(device_t dev)
395 {
396     int		i;
397 
398     i = ciss_lookup(dev);
399     if (i != -1) {
400 	device_set_desc(dev, ciss_vendor_data[i].desc);
401 	return(BUS_PROBE_DEFAULT);
402     }
403     return(ENOENT);
404 }
405 
406 /************************************************************************
407  * Attach the driver to this adapter.
408  */
409 static int
410 ciss_attach(device_t dev)
411 {
412     struct ciss_softc	*sc;
413     int			error;
414 
415     debug_called(1);
416 
417 #ifdef CISS_DEBUG
418     /* print structure/union sizes */
419     debug_struct(ciss_command);
420     debug_struct(ciss_header);
421     debug_union(ciss_device_address);
422     debug_struct(ciss_cdb);
423     debug_struct(ciss_report_cdb);
424     debug_struct(ciss_notify_cdb);
425     debug_struct(ciss_notify);
426     debug_struct(ciss_message_cdb);
427     debug_struct(ciss_error_info_pointer);
428     debug_struct(ciss_error_info);
429     debug_struct(ciss_sg_entry);
430     debug_struct(ciss_config_table);
431     debug_struct(ciss_bmic_cdb);
432     debug_struct(ciss_bmic_id_ldrive);
433     debug_struct(ciss_bmic_id_lstatus);
434     debug_struct(ciss_bmic_id_table);
435     debug_struct(ciss_bmic_id_pdrive);
436     debug_struct(ciss_bmic_blink_pdrive);
437     debug_struct(ciss_bmic_flush_cache);
438     debug_const(CISS_MAX_REQUESTS);
439     debug_const(CISS_MAX_LOGICAL);
440     debug_const(CISS_INTERRUPT_COALESCE_DELAY);
441     debug_const(CISS_INTERRUPT_COALESCE_COUNT);
442     debug_const(CISS_COMMAND_ALLOC_SIZE);
443     debug_const(CISS_COMMAND_SG_LENGTH);
444 
445     debug_type(cciss_pci_info_struct);
446     debug_type(cciss_coalint_struct);
447     debug_type(cciss_coalint_struct);
448     debug_type(NodeName_type);
449     debug_type(NodeName_type);
450     debug_type(Heartbeat_type);
451     debug_type(BusTypes_type);
452     debug_type(FirmwareVer_type);
453     debug_type(DriverVer_type);
454     debug_type(IOCTL_Command_struct);
455 #endif
456 
457     sc = device_get_softc(dev);
458     sc->ciss_dev = dev;
459     mtx_init(&sc->ciss_mtx, "cissmtx", NULL, MTX_DEF);
460     callout_init_mtx(&sc->ciss_periodic, &sc->ciss_mtx, 0);
461 
462     /*
463      * Do PCI-specific init.
464      */
465     if ((error = ciss_init_pci(sc)) != 0)
466 	goto out;
467 
468     /*
469      * Initialise driver queues.
470      */
471     ciss_initq_free(sc);
472     ciss_initq_notify(sc);
473 
474     /*
475      * Initialize device sysctls.
476      */
477     ciss_init_sysctl(sc);
478 
479     /*
480      * Initialise command/request pool.
481      */
482     if ((error = ciss_init_requests(sc)) != 0)
483 	goto out;
484 
485     /*
486      * Get adapter information.
487      */
488     if ((error = ciss_identify_adapter(sc)) != 0)
489 	goto out;
490 
491     /*
492      * Find all the physical devices.
493      */
494     if ((error = ciss_init_physical(sc)) != 0)
495 	goto out;
496 
497     /*
498      * Build our private table of logical devices.
499      */
500     if ((error = ciss_init_logical(sc)) != 0)
501 	goto out;
502 
503     /*
504      * Enable interrupts so that the CAM scan can complete.
505      */
506     CISS_TL_SIMPLE_ENABLE_INTERRUPTS(sc);
507 
508     /*
509      * Initialise the CAM interface.
510      */
511     if ((error = ciss_cam_init(sc)) != 0)
512 	goto out;
513 
514     /*
515      * Start the heartbeat routine and event chain.
516      */
517     ciss_periodic(sc);
518 
519    /*
520      * Create the control device.
521      */
522     sc->ciss_dev_t = make_dev(&ciss_cdevsw, device_get_unit(sc->ciss_dev),
523 			      UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR,
524 			      "ciss%d", device_get_unit(sc->ciss_dev));
525     sc->ciss_dev_t->si_drv1 = sc;
526 
527     /*
528      * The adapter is running; synchronous commands can now sleep
529      * waiting for an interrupt to signal completion.
530      */
531     sc->ciss_flags |= CISS_FLAG_RUNNING;
532 
533     ciss_spawn_notify_thread(sc);
534 
535     error = 0;
536  out:
537     if (error != 0) {
538 	/* ciss_free() expects the mutex to be held */
539 	mtx_lock(&sc->ciss_mtx);
540 	ciss_free(sc);
541     }
542     return(error);
543 }
544 
545 /************************************************************************
546  * Detach the driver from this adapter.
547  */
548 static int
549 ciss_detach(device_t dev)
550 {
551     struct ciss_softc	*sc = device_get_softc(dev);
552 
553     debug_called(1);
554 
555     mtx_lock(&sc->ciss_mtx);
556     if (sc->ciss_flags & CISS_FLAG_CONTROL_OPEN) {
557 	mtx_unlock(&sc->ciss_mtx);
558 	return (EBUSY);
559     }
560 
561     /* flush adapter cache */
562     ciss_flush_adapter(sc);
563 
564     /* release all resources.  The mutex is released and freed here too. */
565     ciss_free(sc);
566 
567     return(0);
568 }
569 
570 /************************************************************************
571  * Prepare adapter for system shutdown.
572  */
573 static int
574 ciss_shutdown(device_t dev)
575 {
576     struct ciss_softc	*sc = device_get_softc(dev);
577 
578     debug_called(1);
579 
580     mtx_lock(&sc->ciss_mtx);
581     /* flush adapter cache */
582     ciss_flush_adapter(sc);
583 
584     if (sc->ciss_soft_reset)
585 	ciss_soft_reset(sc);
586     mtx_unlock(&sc->ciss_mtx);
587 
588     return(0);
589 }
590 
591 static void
592 ciss_init_sysctl(struct ciss_softc *sc)
593 {
594 
595     SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->ciss_dev),
596 	SYSCTL_CHILDREN(device_get_sysctl_tree(sc->ciss_dev)),
597 	OID_AUTO, "soft_reset", CTLFLAG_RW, &sc->ciss_soft_reset, 0, "");
598 }
599 
600 /************************************************************************
601  * Perform PCI-specific attachment actions.
602  */
603 static int
604 ciss_init_pci(struct ciss_softc *sc)
605 {
606     uintptr_t		cbase, csize, cofs;
607     uint32_t		method, supported_methods;
608     int			error, sqmask, i;
609     void		*intr;
610 
611     debug_called(1);
612 
613     /*
614      * Work out adapter type.
615      */
616     i = ciss_lookup(sc->ciss_dev);
617     if (i < 0) {
618 	ciss_printf(sc, "unknown adapter type\n");
619 	return (ENXIO);
620     }
621 
622     if (ciss_vendor_data[i].flags & CISS_BOARD_SA5) {
623 	sqmask = CISS_TL_SIMPLE_INTR_OPQ_SA5;
624     } else if (ciss_vendor_data[i].flags & CISS_BOARD_SA5B) {
625 	sqmask = CISS_TL_SIMPLE_INTR_OPQ_SA5B;
626     } else {
627 	/*
628 	 * XXX Big hammer, masks/unmasks all possible interrupts.  This should
629 	 * work on all hardware variants.  Need to add code to handle the
630 	 * "controller crashed" interrupt bit that this unmasks.
631 	 */
632 	sqmask = ~0;
633     }
634 
635     /*
636      * Allocate register window first (we need this to find the config
637      * struct).
638      */
639     error = ENXIO;
640     sc->ciss_regs_rid = CISS_TL_SIMPLE_BAR_REGS;
641     if ((sc->ciss_regs_resource =
642 	 bus_alloc_resource_any(sc->ciss_dev, SYS_RES_MEMORY,
643 				&sc->ciss_regs_rid, RF_ACTIVE)) == NULL) {
644 	ciss_printf(sc, "can't allocate register window\n");
645 	return(ENXIO);
646     }
647     sc->ciss_regs_bhandle = rman_get_bushandle(sc->ciss_regs_resource);
648     sc->ciss_regs_btag = rman_get_bustag(sc->ciss_regs_resource);
649 
650     /*
651      * Find the BAR holding the config structure.  If it's not the one
652      * we already mapped for registers, map it too.
653      */
654     sc->ciss_cfg_rid = CISS_TL_SIMPLE_READ(sc, CISS_TL_SIMPLE_CFG_BAR) & 0xffff;
655     if (sc->ciss_cfg_rid != sc->ciss_regs_rid) {
656 	if ((sc->ciss_cfg_resource =
657 	     bus_alloc_resource_any(sc->ciss_dev, SYS_RES_MEMORY,
658 				    &sc->ciss_cfg_rid, RF_ACTIVE)) == NULL) {
659 	    ciss_printf(sc, "can't allocate config window\n");
660 	    return(ENXIO);
661 	}
662 	cbase = (uintptr_t)rman_get_virtual(sc->ciss_cfg_resource);
663 	csize = rman_get_end(sc->ciss_cfg_resource) -
664 	    rman_get_start(sc->ciss_cfg_resource) + 1;
665     } else {
666 	cbase = (uintptr_t)rman_get_virtual(sc->ciss_regs_resource);
667 	csize = rman_get_end(sc->ciss_regs_resource) -
668 	    rman_get_start(sc->ciss_regs_resource) + 1;
669     }
670     cofs = CISS_TL_SIMPLE_READ(sc, CISS_TL_SIMPLE_CFG_OFF);
671 
672     /*
673      * Use the base/size/offset values we just calculated to
674      * sanity-check the config structure.  If it's OK, point to it.
675      */
676     if ((cofs + sizeof(struct ciss_config_table)) > csize) {
677 	ciss_printf(sc, "config table outside window\n");
678 	return(ENXIO);
679     }
680     sc->ciss_cfg = (struct ciss_config_table *)(cbase + cofs);
681     debug(1, "config struct at %p", sc->ciss_cfg);
682 
683     /*
684      * Calculate the number of request structures/commands we are
685      * going to provide for this adapter.
686      */
687     sc->ciss_max_requests = min(CISS_MAX_REQUESTS, sc->ciss_cfg->max_outstanding_commands);
688 
689     /*
690      * Validate the config structure.  If we supported other transport
691      * methods, we could select amongst them at this point in time.
692      */
693     if (strncmp(sc->ciss_cfg->signature, "CISS", 4)) {
694 	ciss_printf(sc, "config signature mismatch (got '%c%c%c%c')\n",
695 		    sc->ciss_cfg->signature[0], sc->ciss_cfg->signature[1],
696 		    sc->ciss_cfg->signature[2], sc->ciss_cfg->signature[3]);
697 	return(ENXIO);
698     }
699 
700     /*
701      * Select the mode of operation, prefer Performant.
702      */
703     if (!(sc->ciss_cfg->supported_methods &
704 	(CISS_TRANSPORT_METHOD_SIMPLE | CISS_TRANSPORT_METHOD_PERF))) {
705 	ciss_printf(sc, "No supported transport layers: 0x%x\n",
706 	    sc->ciss_cfg->supported_methods);
707     }
708 
709     switch (ciss_force_transport) {
710     case 1:
711 	supported_methods = CISS_TRANSPORT_METHOD_SIMPLE;
712 	break;
713     case 2:
714 	supported_methods = CISS_TRANSPORT_METHOD_PERF;
715 	break;
716     default:
717         /*
718          * Override the capabilities of the BOARD and specify SIMPLE
719          * MODE
720          */
721         if (ciss_vendor_data[i].flags & CISS_BOARD_SIMPLE)
722                 supported_methods = CISS_TRANSPORT_METHOD_SIMPLE;
723         else
724                 supported_methods = sc->ciss_cfg->supported_methods;
725         break;
726     }
727 
728 setup:
729     if ((supported_methods & CISS_TRANSPORT_METHOD_PERF) != 0) {
730 	method = CISS_TRANSPORT_METHOD_PERF;
731 	sc->ciss_perf = (struct ciss_perf_config *)(cbase + cofs +
732 	    sc->ciss_cfg->transport_offset);
733 	if (ciss_init_perf(sc)) {
734 	    supported_methods &= ~method;
735 	    goto setup;
736 	}
737     } else if (supported_methods & CISS_TRANSPORT_METHOD_SIMPLE) {
738 	method = CISS_TRANSPORT_METHOD_SIMPLE;
739     } else {
740 	ciss_printf(sc, "No supported transport methods: 0x%x\n",
741 	    sc->ciss_cfg->supported_methods);
742 	return(ENXIO);
743     }
744 
745     /*
746      * Tell it we're using the low 4GB of RAM.  Set the default interrupt
747      * coalescing options.
748      */
749     sc->ciss_cfg->requested_method = method;
750     sc->ciss_cfg->command_physlimit = 0;
751     sc->ciss_cfg->interrupt_coalesce_delay = CISS_INTERRUPT_COALESCE_DELAY;
752     sc->ciss_cfg->interrupt_coalesce_count = CISS_INTERRUPT_COALESCE_COUNT;
753 
754 #ifdef __i386__
755     sc->ciss_cfg->host_driver |= CISS_DRIVER_SCSI_PREFETCH;
756 #endif
757 
758     if (ciss_update_config(sc)) {
759 	ciss_printf(sc, "adapter refuses to accept config update (IDBR 0x%x)\n",
760 		    CISS_TL_SIMPLE_READ(sc, CISS_TL_SIMPLE_IDBR));
761 	return(ENXIO);
762     }
763     if ((sc->ciss_cfg->active_method & method) == 0) {
764 	supported_methods &= ~method;
765 	if (supported_methods == 0) {
766 	    ciss_printf(sc, "adapter refuses to go into available transports "
767 		"mode (0x%x, 0x%x)\n", supported_methods,
768 		sc->ciss_cfg->active_method);
769 	    return(ENXIO);
770 	} else
771 	    goto setup;
772     }
773 
774     /*
775      * Wait for the adapter to come ready.
776      */
777     if ((error = ciss_wait_adapter(sc)) != 0)
778 	return(error);
779 
780     /* Prepare to possibly use MSIX and/or PERFORMANT interrupts.  Normal
781      * interrupts have a rid of 0, this will be overridden if MSIX is used.
782      */
783     sc->ciss_irq_rid[0] = 0;
784     if (method == CISS_TRANSPORT_METHOD_PERF) {
785 	ciss_printf(sc, "PERFORMANT Transport\n");
786 	if ((ciss_force_interrupt != 1) && (ciss_setup_msix(sc) == 0)) {
787 	    intr = ciss_perf_msi_intr;
788 	} else {
789 	    intr = ciss_perf_intr;
790 	}
791 	/* XXX The docs say that the 0x01 bit is only for SAS controllers.
792 	 * Unfortunately, there is no good way to know if this is a SAS
793 	 * controller.  Hopefully enabling this bit universally will work OK.
794 	 * It seems to work fine for SA6i controllers.
795 	 */
796 	sc->ciss_interrupt_mask = CISS_TL_PERF_INTR_OPQ | CISS_TL_PERF_INTR_MSI;
797 
798     } else {
799 	ciss_printf(sc, "SIMPLE Transport\n");
800 	/* MSIX doesn't seem to work in SIMPLE mode, only enable if it forced */
801 	if (ciss_force_interrupt == 2)
802 	    /* If this fails, we automatically revert to INTx */
803 	    ciss_setup_msix(sc);
804 	sc->ciss_perf = NULL;
805 	intr = ciss_intr;
806 	sc->ciss_interrupt_mask = sqmask;
807     }
808 
809     /*
810      * Turn off interrupts before we go routing anything.
811      */
812     CISS_TL_SIMPLE_DISABLE_INTERRUPTS(sc);
813 
814     /*
815      * Allocate and set up our interrupt.
816      */
817     if ((sc->ciss_irq_resource =
818 	 bus_alloc_resource_any(sc->ciss_dev, SYS_RES_IRQ, &sc->ciss_irq_rid[0],
819 				RF_ACTIVE | RF_SHAREABLE)) == NULL) {
820 	ciss_printf(sc, "can't allocate interrupt\n");
821 	return(ENXIO);
822     }
823 
824     if (bus_setup_intr(sc->ciss_dev, sc->ciss_irq_resource,
825 		       INTR_TYPE_CAM|INTR_MPSAFE, NULL, intr, sc,
826 		       &sc->ciss_intr)) {
827 	ciss_printf(sc, "can't set up interrupt\n");
828 	return(ENXIO);
829     }
830 
831     /*
832      * Allocate the parent bus DMA tag appropriate for our PCI
833      * interface.
834      *
835      * Note that "simple" adapters can only address within a 32-bit
836      * span.
837      */
838     if (bus_dma_tag_create(bus_get_dma_tag(sc->ciss_dev),/* PCI parent */
839 			   1, 0, 			/* alignment, boundary */
840 			   BUS_SPACE_MAXADDR,		/* lowaddr */
841 			   BUS_SPACE_MAXADDR, 		/* highaddr */
842 			   NULL, NULL, 			/* filter, filterarg */
843 			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsize */
844 			   BUS_SPACE_UNRESTRICTED,	/* nsegments */
845 			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
846 			   0,				/* flags */
847 			   NULL, NULL,			/* lockfunc, lockarg */
848 			   &sc->ciss_parent_dmat)) {
849 	ciss_printf(sc, "can't allocate parent DMA tag\n");
850 	return(ENOMEM);
851     }
852 
853     /*
854      * Create DMA tag for mapping buffers into adapter-addressable
855      * space.
856      */
857     if (bus_dma_tag_create(sc->ciss_parent_dmat, 	/* parent */
858 			   1, 0, 			/* alignment, boundary */
859 			   BUS_SPACE_MAXADDR,		/* lowaddr */
860 			   BUS_SPACE_MAXADDR, 		/* highaddr */
861 			   NULL, NULL, 			/* filter, filterarg */
862 			   (CISS_MAX_SG_ELEMENTS - 1) * PAGE_SIZE, /* maxsize */
863 			   CISS_MAX_SG_ELEMENTS,	/* nsegments */
864 			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
865 			   BUS_DMA_ALLOCNOW,		/* flags */
866 			   busdma_lock_mutex, &sc->ciss_mtx,	/* lockfunc, lockarg */
867 			   &sc->ciss_buffer_dmat)) {
868 	ciss_printf(sc, "can't allocate buffer DMA tag\n");
869 	return(ENOMEM);
870     }
871     return(0);
872 }
873 
874 /************************************************************************
875  * Setup MSI/MSIX operation (Performant only)
876  * Four interrupts are available, but we only use 1 right now.  If MSI-X
877  * isn't avaialble, try using MSI instead.
878  */
879 static int
880 ciss_setup_msix(struct ciss_softc *sc)
881 {
882     int val, i;
883 
884     /* Weed out devices that don't actually support MSI */
885     i = ciss_lookup(sc->ciss_dev);
886     if (ciss_vendor_data[i].flags & CISS_BOARD_NOMSI)
887 	return (EINVAL);
888 
889     /*
890      * Only need to use the minimum number of MSI vectors, as the driver
891      * doesn't support directed MSIX interrupts.
892      */
893     val = pci_msix_count(sc->ciss_dev);
894     if (val < CISS_MSI_COUNT) {
895 	val = pci_msi_count(sc->ciss_dev);
896 	device_printf(sc->ciss_dev, "got %d MSI messages]\n", val);
897 	if (val < CISS_MSI_COUNT)
898 	    return (EINVAL);
899     }
900     val = MIN(val, CISS_MSI_COUNT);
901     if (pci_alloc_msix(sc->ciss_dev, &val) != 0) {
902 	if (pci_alloc_msi(sc->ciss_dev, &val) != 0)
903 	    return (EINVAL);
904     }
905 
906     sc->ciss_msi = val;
907     if (bootverbose)
908 	ciss_printf(sc, "Using %d MSIX interrupt%s\n", val,
909 	    (val != 1) ? "s" : "");
910 
911     for (i = 0; i < val; i++)
912 	sc->ciss_irq_rid[i] = i + 1;
913 
914     return (0);
915 
916 }
917 
918 /************************************************************************
919  * Setup the Performant structures.
920  */
921 static int
922 ciss_init_perf(struct ciss_softc *sc)
923 {
924     struct ciss_perf_config *pc = sc->ciss_perf;
925     int reply_size;
926 
927     /*
928      * Create the DMA tag for the reply queue.
929      */
930     reply_size = sizeof(uint64_t) * sc->ciss_max_requests;
931     if (bus_dma_tag_create(sc->ciss_parent_dmat,	/* parent */
932 			   1, 0, 			/* alignment, boundary */
933 			   BUS_SPACE_MAXADDR_32BIT,	/* lowaddr */
934 			   BUS_SPACE_MAXADDR, 		/* highaddr */
935 			   NULL, NULL, 			/* filter, filterarg */
936 			   reply_size, 1,		/* maxsize, nsegments */
937 			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
938 			   0,				/* flags */
939 			   NULL, NULL,			/* lockfunc, lockarg */
940 			   &sc->ciss_reply_dmat)) {
941 	ciss_printf(sc, "can't allocate reply DMA tag\n");
942 	return(ENOMEM);
943     }
944     /*
945      * Allocate memory and make it available for DMA.
946      */
947     if (bus_dmamem_alloc(sc->ciss_reply_dmat, (void **)&sc->ciss_reply,
948 			 BUS_DMA_NOWAIT, &sc->ciss_reply_map)) {
949 	ciss_printf(sc, "can't allocate reply memory\n");
950 	return(ENOMEM);
951     }
952     bus_dmamap_load(sc->ciss_reply_dmat, sc->ciss_reply_map, sc->ciss_reply,
953 		    reply_size, ciss_command_map_helper, &sc->ciss_reply_phys, 0);
954     bzero(sc->ciss_reply, reply_size);
955 
956     sc->ciss_cycle = 0x1;
957     sc->ciss_rqidx = 0;
958 
959     /*
960      * Preload the fetch table with common command sizes.  This allows the
961      * hardware to not waste bus cycles for typical i/o commands, but also not
962      * tax the driver to be too exact in choosing sizes.  The table is optimized
963      * for page-aligned i/o's, but since most i/o comes from the various pagers,
964      * it's a reasonable assumption to make.
965      */
966     pc->fetch_count[CISS_SG_FETCH_NONE] = (sizeof(struct ciss_command) + 15) / 16;
967     pc->fetch_count[CISS_SG_FETCH_1] =
968 	(sizeof(struct ciss_command) + sizeof(struct ciss_sg_entry) * 1 + 15) / 16;
969     pc->fetch_count[CISS_SG_FETCH_2] =
970 	(sizeof(struct ciss_command) + sizeof(struct ciss_sg_entry) * 2 + 15) / 16;
971     pc->fetch_count[CISS_SG_FETCH_4] =
972 	(sizeof(struct ciss_command) + sizeof(struct ciss_sg_entry) * 4 + 15) / 16;
973     pc->fetch_count[CISS_SG_FETCH_8] =
974 	(sizeof(struct ciss_command) + sizeof(struct ciss_sg_entry) * 8 + 15) / 16;
975     pc->fetch_count[CISS_SG_FETCH_16] =
976 	(sizeof(struct ciss_command) + sizeof(struct ciss_sg_entry) * 16 + 15) / 16;
977     pc->fetch_count[CISS_SG_FETCH_32] =
978 	(sizeof(struct ciss_command) + sizeof(struct ciss_sg_entry) * 32 + 15) / 16;
979     pc->fetch_count[CISS_SG_FETCH_MAX] = (CISS_COMMAND_ALLOC_SIZE + 15) / 16;
980 
981     pc->rq_size = sc->ciss_max_requests; /* XXX less than the card supports? */
982     pc->rq_count = 1;	/* XXX Hardcode for a single queue */
983     pc->rq_bank_hi = 0;
984     pc->rq_bank_lo = 0;
985     pc->rq[0].rq_addr_hi = 0x0;
986     pc->rq[0].rq_addr_lo = sc->ciss_reply_phys;
987 
988     return(0);
989 }
990 
991 /************************************************************************
992  * Wait for the adapter to come ready.
993  */
994 static int
995 ciss_wait_adapter(struct ciss_softc *sc)
996 {
997     int		i;
998 
999     debug_called(1);
1000 
1001     /*
1002      * Wait for the adapter to come ready.
1003      */
1004     if (!(sc->ciss_cfg->active_method & CISS_TRANSPORT_METHOD_READY)) {
1005 	ciss_printf(sc, "waiting for adapter to come ready...\n");
1006 	for (i = 0; !(sc->ciss_cfg->active_method & CISS_TRANSPORT_METHOD_READY); i++) {
1007 	    DELAY(1000000);	/* one second */
1008 	    if (i > 30) {
1009 		ciss_printf(sc, "timed out waiting for adapter to come ready\n");
1010 		return(EIO);
1011 	    }
1012 	}
1013     }
1014     return(0);
1015 }
1016 
1017 /************************************************************************
1018  * Flush the adapter cache.
1019  */
1020 static int
1021 ciss_flush_adapter(struct ciss_softc *sc)
1022 {
1023     struct ciss_request			*cr;
1024     struct ciss_bmic_flush_cache	*cbfc;
1025     int					error, command_status;
1026 
1027     debug_called(1);
1028 
1029     cr = NULL;
1030     cbfc = NULL;
1031 
1032     /*
1033      * Build a BMIC request to flush the cache.  We don't disable
1034      * it, as we may be going to do more I/O (eg. we are emulating
1035      * the Synchronise Cache command).
1036      */
1037     if ((cbfc = malloc(sizeof(*cbfc), CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO)) == NULL) {
1038 	error = ENOMEM;
1039 	goto out;
1040     }
1041     if ((error = ciss_get_bmic_request(sc, &cr, CISS_BMIC_FLUSH_CACHE,
1042 				       (void **)&cbfc, sizeof(*cbfc))) != 0)
1043 	goto out;
1044 
1045     /*
1046      * Submit the request and wait for it to complete.
1047      */
1048     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
1049 	ciss_printf(sc, "error sending BMIC FLUSH_CACHE command (%d)\n", error);
1050 	goto out;
1051     }
1052 
1053     /*
1054      * Check response.
1055      */
1056     ciss_report_request(cr, &command_status, NULL);
1057     switch(command_status) {
1058     case CISS_CMD_STATUS_SUCCESS:
1059 	break;
1060     default:
1061 	ciss_printf(sc, "error flushing cache (%s)\n",
1062 		    ciss_name_command_status(command_status));
1063 	error = EIO;
1064 	goto out;
1065     }
1066 
1067 out:
1068     if (cbfc != NULL)
1069 	free(cbfc, CISS_MALLOC_CLASS);
1070     if (cr != NULL)
1071 	ciss_release_request(cr);
1072     return(error);
1073 }
1074 
1075 static void
1076 ciss_soft_reset(struct ciss_softc *sc)
1077 {
1078     struct ciss_request		*cr = NULL;
1079     struct ciss_command		*cc;
1080     int				i, error = 0;
1081 
1082     for (i = 0; i < sc->ciss_max_logical_bus; i++) {
1083 	/* only reset proxy controllers */
1084 	if (sc->ciss_controllers[i].physical.bus == 0)
1085 	    continue;
1086 
1087 	if ((error = ciss_get_request(sc, &cr)) != 0)
1088 	    break;
1089 
1090 	if ((error = ciss_get_bmic_request(sc, &cr, CISS_BMIC_SOFT_RESET,
1091 					   NULL, 0)) != 0)
1092 	    break;
1093 
1094 	cc = cr->cr_cc;
1095 	cc->header.address = sc->ciss_controllers[i];
1096 
1097 	if ((error = ciss_synch_request(cr, 60 * 1000)) != 0)
1098 	    break;
1099 
1100 	ciss_release_request(cr);
1101     }
1102 
1103     if (error)
1104 	ciss_printf(sc, "error resetting controller (%d)\n", error);
1105 
1106     if (cr != NULL)
1107 	ciss_release_request(cr);
1108 }
1109 
1110 /************************************************************************
1111  * Allocate memory for the adapter command structures, initialise
1112  * the request structures.
1113  *
1114  * Note that the entire set of commands are allocated in a single
1115  * contiguous slab.
1116  */
1117 static int
1118 ciss_init_requests(struct ciss_softc *sc)
1119 {
1120     struct ciss_request	*cr;
1121     int			i;
1122 
1123     debug_called(1);
1124 
1125     if (bootverbose)
1126 	ciss_printf(sc, "using %d of %d available commands\n",
1127 		    sc->ciss_max_requests, sc->ciss_cfg->max_outstanding_commands);
1128 
1129     /*
1130      * Create the DMA tag for commands.
1131      */
1132     if (bus_dma_tag_create(sc->ciss_parent_dmat,	/* parent */
1133 			   32, 0, 			/* alignment, boundary */
1134 			   BUS_SPACE_MAXADDR_32BIT,	/* lowaddr */
1135 			   BUS_SPACE_MAXADDR, 		/* highaddr */
1136 			   NULL, NULL, 			/* filter, filterarg */
1137 			   CISS_COMMAND_ALLOC_SIZE *
1138 			   sc->ciss_max_requests, 1,	/* maxsize, nsegments */
1139 			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
1140 			   0,				/* flags */
1141 			   NULL, NULL,			/* lockfunc, lockarg */
1142 			   &sc->ciss_command_dmat)) {
1143 	ciss_printf(sc, "can't allocate command DMA tag\n");
1144 	return(ENOMEM);
1145     }
1146     /*
1147      * Allocate memory and make it available for DMA.
1148      */
1149     if (bus_dmamem_alloc(sc->ciss_command_dmat, (void **)&sc->ciss_command,
1150 			 BUS_DMA_NOWAIT, &sc->ciss_command_map)) {
1151 	ciss_printf(sc, "can't allocate command memory\n");
1152 	return(ENOMEM);
1153     }
1154     bus_dmamap_load(sc->ciss_command_dmat, sc->ciss_command_map,sc->ciss_command,
1155 		    CISS_COMMAND_ALLOC_SIZE * sc->ciss_max_requests,
1156 		    ciss_command_map_helper, &sc->ciss_command_phys, 0);
1157     bzero(sc->ciss_command, CISS_COMMAND_ALLOC_SIZE * sc->ciss_max_requests);
1158 
1159     /*
1160      * Set up the request and command structures, push requests onto
1161      * the free queue.
1162      */
1163     for (i = 1; i < sc->ciss_max_requests; i++) {
1164 	cr = &sc->ciss_request[i];
1165 	cr->cr_sc = sc;
1166 	cr->cr_tag = i;
1167 	cr->cr_cc = (struct ciss_command *)((uintptr_t)sc->ciss_command +
1168 	    CISS_COMMAND_ALLOC_SIZE * i);
1169 	cr->cr_ccphys = sc->ciss_command_phys + CISS_COMMAND_ALLOC_SIZE * i;
1170 	bus_dmamap_create(sc->ciss_buffer_dmat, 0, &cr->cr_datamap);
1171 	ciss_enqueue_free(cr);
1172     }
1173     return(0);
1174 }
1175 
1176 static void
1177 ciss_command_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1178 {
1179     uint32_t *addr;
1180 
1181     addr = arg;
1182     *addr = segs[0].ds_addr;
1183 }
1184 
1185 /************************************************************************
1186  * Identify the adapter, print some information about it.
1187  */
1188 static int
1189 ciss_identify_adapter(struct ciss_softc *sc)
1190 {
1191     struct ciss_request	*cr;
1192     int			error, command_status;
1193 
1194     debug_called(1);
1195 
1196     cr = NULL;
1197 
1198     /*
1199      * Get a request, allocate storage for the adapter data.
1200      */
1201     if ((error = ciss_get_bmic_request(sc, &cr, CISS_BMIC_ID_CTLR,
1202 				       (void **)&sc->ciss_id,
1203 				       sizeof(*sc->ciss_id))) != 0)
1204 	goto out;
1205 
1206     /*
1207      * Submit the request and wait for it to complete.
1208      */
1209     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
1210 	ciss_printf(sc, "error sending BMIC ID_CTLR command (%d)\n", error);
1211 	goto out;
1212     }
1213 
1214     /*
1215      * Check response.
1216      */
1217     ciss_report_request(cr, &command_status, NULL);
1218     switch(command_status) {
1219     case CISS_CMD_STATUS_SUCCESS:		/* buffer right size */
1220 	break;
1221     case CISS_CMD_STATUS_DATA_UNDERRUN:
1222     case CISS_CMD_STATUS_DATA_OVERRUN:
1223 	ciss_printf(sc, "data over/underrun reading adapter information\n");
1224     default:
1225 	ciss_printf(sc, "error reading adapter information (%s)\n",
1226 		    ciss_name_command_status(command_status));
1227 	error = EIO;
1228 	goto out;
1229     }
1230 
1231     /* sanity-check reply */
1232     if (!(sc->ciss_id->controller_flags & CONTROLLER_FLAGS_BIG_MAP_SUPPORT)) {
1233 	ciss_printf(sc, "adapter does not support BIG_MAP\n");
1234 	error = ENXIO;
1235 	goto out;
1236     }
1237 
1238 #if 0
1239     /* XXX later revisions may not need this */
1240     sc->ciss_flags |= CISS_FLAG_FAKE_SYNCH;
1241 #endif
1242 
1243     /* XXX only really required for old 5300 adapters? */
1244     sc->ciss_flags |= CISS_FLAG_BMIC_ABORT;
1245 
1246     /*
1247      * Earlier controller specs do not contain these config
1248      * entries, so assume that a 0 means its old and assign
1249      * these values to the defaults that were established
1250      * when this driver was developed for them
1251      */
1252     if (sc->ciss_cfg->max_logical_supported == 0)
1253         sc->ciss_cfg->max_logical_supported = CISS_MAX_LOGICAL;
1254     if (sc->ciss_cfg->max_physical_supported == 0)
1255 	sc->ciss_cfg->max_physical_supported = CISS_MAX_PHYSICAL;
1256     /* print information */
1257     if (bootverbose) {
1258 	ciss_printf(sc, "  %d logical drive%s configured\n",
1259 		    sc->ciss_id->configured_logical_drives,
1260 		    (sc->ciss_id->configured_logical_drives == 1) ? "" : "s");
1261 	ciss_printf(sc, "  firmware %4.4s\n", sc->ciss_id->running_firmware_revision);
1262 	ciss_printf(sc, "  %d SCSI channels\n", sc->ciss_id->scsi_chip_count);
1263 
1264 	ciss_printf(sc, "  signature '%.4s'\n", sc->ciss_cfg->signature);
1265 	ciss_printf(sc, "  valence %d\n", sc->ciss_cfg->valence);
1266 	ciss_printf(sc, "  supported I/O methods 0x%b\n",
1267 		    sc->ciss_cfg->supported_methods,
1268 		    "\20\1READY\2simple\3performant\4MEMQ\n");
1269 	ciss_printf(sc, "  active I/O method 0x%b\n",
1270 		    sc->ciss_cfg->active_method, "\20\2simple\3performant\4MEMQ\n");
1271 	ciss_printf(sc, "  4G page base 0x%08x\n",
1272 		    sc->ciss_cfg->command_physlimit);
1273 	ciss_printf(sc, "  interrupt coalesce delay %dus\n",
1274 		    sc->ciss_cfg->interrupt_coalesce_delay);
1275 	ciss_printf(sc, "  interrupt coalesce count %d\n",
1276 		    sc->ciss_cfg->interrupt_coalesce_count);
1277 	ciss_printf(sc, "  max outstanding commands %d\n",
1278 		    sc->ciss_cfg->max_outstanding_commands);
1279 	ciss_printf(sc, "  bus types 0x%b\n", sc->ciss_cfg->bus_types,
1280 		    "\20\1ultra2\2ultra3\10fibre1\11fibre2\n");
1281 	ciss_printf(sc, "  server name '%.16s'\n", sc->ciss_cfg->server_name);
1282 	ciss_printf(sc, "  heartbeat 0x%x\n", sc->ciss_cfg->heartbeat);
1283 	ciss_printf(sc, "  max logical volumes: %d\n", sc->ciss_cfg->max_logical_supported);
1284     	ciss_printf(sc, "  max physical disks supported: %d\n", sc->ciss_cfg->max_physical_supported);
1285     	ciss_printf(sc, "  max physical disks per logical volume: %d\n", sc->ciss_cfg->max_physical_per_logical);
1286 	ciss_printf(sc, "  JBOD Support is %s\n", (sc->ciss_id->uiYetMoreControllerFlags & YMORE_CONTROLLER_FLAGS_JBOD_SUPPORTED) ?
1287 			"Available" : "Unavailable");
1288 	ciss_printf(sc, "  JBOD Mode is %s\n", (sc->ciss_id->PowerUPNvramFlags & PWR_UP_FLAG_JBOD_ENABLED) ?
1289 			"Enabled" : "Disabled");
1290     }
1291 
1292 out:
1293     if (error) {
1294 	if (sc->ciss_id != NULL) {
1295 	    free(sc->ciss_id, CISS_MALLOC_CLASS);
1296 	    sc->ciss_id = NULL;
1297 	}
1298     }
1299     if (cr != NULL)
1300 	ciss_release_request(cr);
1301     return(error);
1302 }
1303 
1304 /************************************************************************
1305  * Helper routine for generating a list of logical and physical luns.
1306  */
1307 static struct ciss_lun_report *
1308 ciss_report_luns(struct ciss_softc *sc, int opcode, int nunits)
1309 {
1310     struct ciss_request		*cr;
1311     struct ciss_command		*cc;
1312     struct ciss_report_cdb	*crc;
1313     struct ciss_lun_report	*cll;
1314     int				command_status;
1315     int				report_size;
1316     int				error = 0;
1317 
1318     debug_called(1);
1319 
1320     cr = NULL;
1321     cll = NULL;
1322 
1323     /*
1324      * Get a request, allocate storage for the address list.
1325      */
1326     if ((error = ciss_get_request(sc, &cr)) != 0)
1327 	goto out;
1328     report_size = sizeof(*cll) + nunits * sizeof(union ciss_device_address);
1329     if ((cll = malloc(report_size, CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO)) == NULL) {
1330 	ciss_printf(sc, "can't allocate memory for lun report\n");
1331 	error = ENOMEM;
1332 	goto out;
1333     }
1334 
1335     /*
1336      * Build the Report Logical/Physical LUNs command.
1337      */
1338     cc = cr->cr_cc;
1339     cr->cr_data = cll;
1340     cr->cr_length = report_size;
1341     cr->cr_flags = CISS_REQ_DATAIN;
1342 
1343     cc->header.address.physical.mode = CISS_HDR_ADDRESS_MODE_PERIPHERAL;
1344     cc->header.address.physical.bus = 0;
1345     cc->header.address.physical.target = 0;
1346     cc->cdb.cdb_length = sizeof(*crc);
1347     cc->cdb.type = CISS_CDB_TYPE_COMMAND;
1348     cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;
1349     cc->cdb.direction = CISS_CDB_DIRECTION_READ;
1350     cc->cdb.timeout = 30;	/* XXX better suggestions? */
1351 
1352     crc = (struct ciss_report_cdb *)&(cc->cdb.cdb[0]);
1353     bzero(crc, sizeof(*crc));
1354     crc->opcode = opcode;
1355     crc->length = htonl(report_size);			/* big-endian field */
1356     cll->list_size = htonl(report_size - sizeof(*cll));	/* big-endian field */
1357 
1358     /*
1359      * Submit the request and wait for it to complete.  (timeout
1360      * here should be much greater than above)
1361      */
1362     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
1363 	ciss_printf(sc, "error sending %d LUN command (%d)\n", opcode, error);
1364 	goto out;
1365     }
1366 
1367     /*
1368      * Check response.  Note that data over/underrun is OK.
1369      */
1370     ciss_report_request(cr, &command_status, NULL);
1371     switch(command_status) {
1372     case CISS_CMD_STATUS_SUCCESS:	/* buffer right size */
1373     case CISS_CMD_STATUS_DATA_UNDERRUN:	/* buffer too large, not bad */
1374 	break;
1375     case CISS_CMD_STATUS_DATA_OVERRUN:
1376 	ciss_printf(sc, "WARNING: more units than driver limit (%d)\n",
1377 		    sc->ciss_cfg->max_logical_supported);
1378 	break;
1379     default:
1380 	ciss_printf(sc, "error detecting logical drive configuration (%s)\n",
1381 		    ciss_name_command_status(command_status));
1382 	error = EIO;
1383 	goto out;
1384     }
1385     ciss_release_request(cr);
1386     cr = NULL;
1387 
1388 out:
1389     if (cr != NULL)
1390 	ciss_release_request(cr);
1391     if (error && cll != NULL) {
1392 	free(cll, CISS_MALLOC_CLASS);
1393 	cll = NULL;
1394     }
1395     return(cll);
1396 }
1397 
1398 /************************************************************************
1399  * Find logical drives on the adapter.
1400  */
1401 static int
1402 ciss_init_logical(struct ciss_softc *sc)
1403 {
1404     struct ciss_lun_report	*cll;
1405     int				error = 0, i, j;
1406     int				ndrives;
1407 
1408     debug_called(1);
1409 
1410     cll = ciss_report_luns(sc, CISS_OPCODE_REPORT_LOGICAL_LUNS,
1411 			   sc->ciss_cfg->max_logical_supported);
1412     if (cll == NULL) {
1413 	error = ENXIO;
1414 	goto out;
1415     }
1416 
1417     /* sanity-check reply */
1418     ndrives = (ntohl(cll->list_size) / sizeof(union ciss_device_address));
1419     if ((ndrives < 0) || (ndrives > sc->ciss_cfg->max_logical_supported)) {
1420 	ciss_printf(sc, "adapter claims to report absurd number of logical drives (%d > %d)\n",
1421 	    	ndrives, sc->ciss_cfg->max_logical_supported);
1422 	error = ENXIO;
1423 	goto out;
1424     }
1425 
1426     /*
1427      * Save logical drive information.
1428      */
1429     if (bootverbose) {
1430 	ciss_printf(sc, "%d logical drive%s\n",
1431 	    ndrives, (ndrives > 1 || ndrives == 0) ? "s" : "");
1432     }
1433 
1434     sc->ciss_logical =
1435 	malloc(sc->ciss_max_logical_bus * sizeof(struct ciss_ldrive *),
1436 	       CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
1437     if (sc->ciss_logical == NULL) {
1438 	error = ENXIO;
1439 	goto out;
1440     }
1441 
1442     for (i = 0; i < sc->ciss_max_logical_bus; i++) {
1443 	sc->ciss_logical[i] =
1444 	    malloc(sc->ciss_cfg->max_logical_supported *
1445 		   sizeof(struct ciss_ldrive),
1446 		   CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
1447 	if (sc->ciss_logical[i] == NULL) {
1448 	    error = ENXIO;
1449 	    goto out;
1450 	}
1451 
1452 	for (j = 0; j < sc->ciss_cfg->max_logical_supported; j++)
1453 	    sc->ciss_logical[i][j].cl_status = CISS_LD_NONEXISTENT;
1454     }
1455 
1456     for (i = 0; i < sc->ciss_cfg->max_logical_supported; i++) {
1457 	if (i < ndrives) {
1458 	    struct ciss_ldrive	*ld;
1459 	    int			bus, target;
1460 
1461 	    bus		= CISS_LUN_TO_BUS(cll->lun[i].logical.lun);
1462 	    target	= CISS_LUN_TO_TARGET(cll->lun[i].logical.lun);
1463 	    ld		= &sc->ciss_logical[bus][target];
1464 
1465 	    ld->cl_address	= cll->lun[i];
1466 	    ld->cl_controller	= &sc->ciss_controllers[bus];
1467 	    if (ciss_identify_logical(sc, ld) != 0)
1468 		continue;
1469 	    /*
1470 	     * If the drive has had media exchanged, we should bring it online.
1471 	     */
1472 	    if (ld->cl_lstatus->media_exchanged)
1473 		ciss_accept_media(sc, ld);
1474 	}
1475     }
1476 
1477  out:
1478     if (cll != NULL)
1479 	free(cll, CISS_MALLOC_CLASS);
1480     return(error);
1481 }
1482 
1483 static int
1484 ciss_init_physical(struct ciss_softc *sc)
1485 {
1486     struct ciss_lun_report	*cll;
1487     int				error = 0, i;
1488     int				nphys;
1489     int				bus;
1490 
1491     debug_called(1);
1492 
1493     bus = 0;
1494 
1495     cll = ciss_report_luns(sc, CISS_OPCODE_REPORT_PHYSICAL_LUNS,
1496 			   sc->ciss_cfg->max_physical_supported);
1497     if (cll == NULL) {
1498 	error = ENXIO;
1499 	goto out;
1500     }
1501 
1502     nphys = (ntohl(cll->list_size) / sizeof(union ciss_device_address));
1503 
1504     if (bootverbose) {
1505 	ciss_printf(sc, "%d physical device%s\n",
1506 	    nphys, (nphys > 1 || nphys == 0) ? "s" : "");
1507     }
1508 
1509     /*
1510      * Figure out the bus mapping.
1511      * Logical buses include both the local logical bus for local arrays and
1512      * proxy buses for remote arrays.  Physical buses are numbered by the
1513      * controller and represent physical buses that hold physical devices.
1514      * We shift these bus numbers so that everything fits into a single flat
1515      * numbering space for CAM.  Logical buses occupy the first 32 CAM bus
1516      * numbers, and the physical bus numbers are shifted to be above that.
1517      * This results in the various driver arrays being indexed as follows:
1518      *
1519      * ciss_controllers[] - indexed by logical bus
1520      * ciss_cam_sim[]     - indexed by both logical and physical, with physical
1521      *                      being shifted by 32.
1522      * ciss_logical[][]   - indexed by logical bus
1523      * ciss_physical[][]  - indexed by physical bus
1524      *
1525      * XXX This is getting more and more hackish.  CISS really doesn't play
1526      *     well with a standard SCSI model; devices are addressed via magic
1527      *     cookies, not via b/t/l addresses.  Since there is no way to store
1528      *     the cookie in the CAM device object, we have to keep these lookup
1529      *     tables handy so that the devices can be found quickly at the cost
1530      *     of wasting memory and having a convoluted lookup scheme.  This
1531      *     driver should probably be converted to block interface.
1532      */
1533     /*
1534      * If the L2 and L3 SCSI addresses are 0, this signifies a proxy
1535      * controller. A proxy controller is another physical controller
1536      * behind the primary PCI controller. We need to know about this
1537      * so that BMIC commands can be properly targeted.  There can be
1538      * proxy controllers attached to a single PCI controller, so
1539      * find the highest numbered one so the array can be properly
1540      * sized.
1541      */
1542     sc->ciss_max_logical_bus = 1;
1543     for (i = 0; i < nphys; i++) {
1544 	if (cll->lun[i].physical.extra_address == 0) {
1545 	    bus = cll->lun[i].physical.bus;
1546 	    sc->ciss_max_logical_bus = max(sc->ciss_max_logical_bus, bus) + 1;
1547 	} else {
1548 	    bus = CISS_EXTRA_BUS2(cll->lun[i].physical.extra_address);
1549 	    sc->ciss_max_physical_bus = max(sc->ciss_max_physical_bus, bus);
1550 	}
1551     }
1552 
1553     sc->ciss_controllers =
1554 	malloc(sc->ciss_max_logical_bus * sizeof (union ciss_device_address),
1555 	       CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
1556 
1557     if (sc->ciss_controllers == NULL) {
1558 	ciss_printf(sc, "Could not allocate memory for controller map\n");
1559 	error = ENOMEM;
1560 	goto out;
1561     }
1562 
1563     /* setup a map of controller addresses */
1564     for (i = 0; i < nphys; i++) {
1565 	if (cll->lun[i].physical.extra_address == 0) {
1566 	    sc->ciss_controllers[cll->lun[i].physical.bus] = cll->lun[i];
1567 	}
1568     }
1569 
1570     sc->ciss_physical =
1571 	malloc(sc->ciss_max_physical_bus * sizeof(struct ciss_pdrive *),
1572 	       CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
1573     if (sc->ciss_physical == NULL) {
1574 	ciss_printf(sc, "Could not allocate memory for physical device map\n");
1575 	error = ENOMEM;
1576 	goto out;
1577     }
1578 
1579     for (i = 0; i < sc->ciss_max_physical_bus; i++) {
1580 	sc->ciss_physical[i] =
1581 	    malloc(sizeof(struct ciss_pdrive) * CISS_MAX_PHYSTGT,
1582 		   CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
1583 	if (sc->ciss_physical[i] == NULL) {
1584 	    ciss_printf(sc, "Could not allocate memory for target map\n");
1585 	    error = ENOMEM;
1586 	    goto out;
1587 	}
1588     }
1589 
1590     ciss_filter_physical(sc, cll);
1591 
1592 out:
1593     if (cll != NULL)
1594 	free(cll, CISS_MALLOC_CLASS);
1595 
1596     return(error);
1597 }
1598 
1599 static int
1600 ciss_filter_physical(struct ciss_softc *sc, struct ciss_lun_report *cll)
1601 {
1602     u_int32_t ea;
1603     int i, nphys;
1604     int	bus, target;
1605 
1606     nphys = (ntohl(cll->list_size) / sizeof(union ciss_device_address));
1607     for (i = 0; i < nphys; i++) {
1608 	if (cll->lun[i].physical.extra_address == 0)
1609 	    continue;
1610 
1611 	/*
1612 	 * Filter out devices that we don't want.  Level 3 LUNs could
1613 	 * probably be supported, but the docs don't give enough of a
1614 	 * hint to know how.
1615 	 *
1616 	 * The mode field of the physical address is likely set to have
1617 	 * hard disks masked out.  Honor it unless the user has overridden
1618 	 * us with the tunable.  We also munge the inquiry data for these
1619 	 * disks so that they only show up as passthrough devices.  Keeping
1620 	 * them visible in this fashion is useful for doing things like
1621 	 * flashing firmware.
1622 	 */
1623 	ea = cll->lun[i].physical.extra_address;
1624 	if ((CISS_EXTRA_BUS3(ea) != 0) || (CISS_EXTRA_TARGET3(ea) != 0) ||
1625 	    (CISS_EXTRA_MODE2(ea) == 0x3))
1626 	    continue;
1627 	if ((ciss_expose_hidden_physical == 0) &&
1628 	   (cll->lun[i].physical.mode == CISS_HDR_ADDRESS_MODE_MASK_PERIPHERAL))
1629 	    continue;
1630 
1631 	/*
1632 	 * Note: CISS firmware numbers physical busses starting at '1', not
1633 	 *       '0'.  This numbering is internal to the firmware and is only
1634 	 *       used as a hint here.
1635 	 */
1636 	bus = CISS_EXTRA_BUS2(ea) - 1;
1637 	target = CISS_EXTRA_TARGET2(ea);
1638 	sc->ciss_physical[bus][target].cp_address = cll->lun[i];
1639 	sc->ciss_physical[bus][target].cp_online = 1;
1640     }
1641 
1642     return (0);
1643 }
1644 
1645 static int
1646 ciss_inquiry_logical(struct ciss_softc *sc, struct ciss_ldrive *ld)
1647 {
1648     struct ciss_request			*cr;
1649     struct ciss_command			*cc;
1650     struct scsi_inquiry			*inq;
1651     int					error;
1652     int					command_status;
1653 
1654     cr = NULL;
1655 
1656     bzero(&ld->cl_geometry, sizeof(ld->cl_geometry));
1657 
1658     if ((error = ciss_get_request(sc, &cr)) != 0)
1659 	goto out;
1660 
1661     cc = cr->cr_cc;
1662     cr->cr_data = &ld->cl_geometry;
1663     cr->cr_length = sizeof(ld->cl_geometry);
1664     cr->cr_flags = CISS_REQ_DATAIN;
1665 
1666     cc->header.address = ld->cl_address;
1667     cc->cdb.cdb_length = 6;
1668     cc->cdb.type = CISS_CDB_TYPE_COMMAND;
1669     cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;
1670     cc->cdb.direction = CISS_CDB_DIRECTION_READ;
1671     cc->cdb.timeout = 30;
1672 
1673     inq = (struct scsi_inquiry *)&(cc->cdb.cdb[0]);
1674     inq->opcode = INQUIRY;
1675     inq->byte2 = SI_EVPD;
1676     inq->page_code = CISS_VPD_LOGICAL_DRIVE_GEOMETRY;
1677     scsi_ulto2b(sizeof(ld->cl_geometry), inq->length);
1678 
1679     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
1680 	ciss_printf(sc, "error getting geometry (%d)\n", error);
1681 	goto out;
1682     }
1683 
1684     ciss_report_request(cr, &command_status, NULL);
1685     switch(command_status) {
1686     case CISS_CMD_STATUS_SUCCESS:
1687     case CISS_CMD_STATUS_DATA_UNDERRUN:
1688 	break;
1689     case CISS_CMD_STATUS_DATA_OVERRUN:
1690 	ciss_printf(sc, "WARNING: Data overrun\n");
1691 	break;
1692     default:
1693 	ciss_printf(sc, "Error detecting logical drive geometry (%s)\n",
1694 		    ciss_name_command_status(command_status));
1695 	break;
1696     }
1697 
1698 out:
1699     if (cr != NULL)
1700 	ciss_release_request(cr);
1701     return(error);
1702 }
1703 /************************************************************************
1704  * Identify a logical drive, initialise state related to it.
1705  */
1706 static int
1707 ciss_identify_logical(struct ciss_softc *sc, struct ciss_ldrive *ld)
1708 {
1709     struct ciss_request		*cr;
1710     struct ciss_command		*cc;
1711     struct ciss_bmic_cdb	*cbc;
1712     int				error, command_status;
1713 
1714     debug_called(1);
1715 
1716     cr = NULL;
1717 
1718     /*
1719      * Build a BMIC request to fetch the drive ID.
1720      */
1721     if ((error = ciss_get_bmic_request(sc, &cr, CISS_BMIC_ID_LDRIVE,
1722 				       (void **)&ld->cl_ldrive,
1723 				       sizeof(*ld->cl_ldrive))) != 0)
1724 	goto out;
1725     cc = cr->cr_cc;
1726     cc->header.address = *ld->cl_controller;	/* target controller */
1727     cbc = (struct ciss_bmic_cdb *)&(cc->cdb.cdb[0]);
1728     cbc->log_drive = CISS_LUN_TO_TARGET(ld->cl_address.logical.lun);
1729 
1730     /*
1731      * Submit the request and wait for it to complete.
1732      */
1733     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
1734 	ciss_printf(sc, "error sending BMIC LDRIVE command (%d)\n", error);
1735 	goto out;
1736     }
1737 
1738     /*
1739      * Check response.
1740      */
1741     ciss_report_request(cr, &command_status, NULL);
1742     switch(command_status) {
1743     case CISS_CMD_STATUS_SUCCESS:		/* buffer right size */
1744 	break;
1745     case CISS_CMD_STATUS_DATA_UNDERRUN:
1746     case CISS_CMD_STATUS_DATA_OVERRUN:
1747 	ciss_printf(sc, "data over/underrun reading logical drive ID\n");
1748     default:
1749 	ciss_printf(sc, "error reading logical drive ID (%s)\n",
1750 		    ciss_name_command_status(command_status));
1751 	error = EIO;
1752 	goto out;
1753     }
1754     ciss_release_request(cr);
1755     cr = NULL;
1756 
1757     /*
1758      * Build a CISS BMIC command to get the logical drive status.
1759      */
1760     if ((error = ciss_get_ldrive_status(sc, ld)) != 0)
1761 	goto out;
1762 
1763     /*
1764      * Get the logical drive geometry.
1765      */
1766     if ((error = ciss_inquiry_logical(sc, ld)) != 0)
1767 	goto out;
1768 
1769     /*
1770      * Print the drive's basic characteristics.
1771      */
1772     if (bootverbose) {
1773 	ciss_printf(sc, "logical drive (b%dt%d): %s, %dMB ",
1774 		    CISS_LUN_TO_BUS(ld->cl_address.logical.lun),
1775 		    CISS_LUN_TO_TARGET(ld->cl_address.logical.lun),
1776 		    ciss_name_ldrive_org(ld->cl_ldrive->fault_tolerance),
1777 		    ((ld->cl_ldrive->blocks_available / (1024 * 1024)) *
1778 		     ld->cl_ldrive->block_size));
1779 
1780 	ciss_print_ldrive(sc, ld);
1781     }
1782 out:
1783     if (error != 0) {
1784 	/* make the drive not-exist */
1785 	ld->cl_status = CISS_LD_NONEXISTENT;
1786 	if (ld->cl_ldrive != NULL) {
1787 	    free(ld->cl_ldrive, CISS_MALLOC_CLASS);
1788 	    ld->cl_ldrive = NULL;
1789 	}
1790 	if (ld->cl_lstatus != NULL) {
1791 	    free(ld->cl_lstatus, CISS_MALLOC_CLASS);
1792 	    ld->cl_lstatus = NULL;
1793 	}
1794     }
1795     if (cr != NULL)
1796 	ciss_release_request(cr);
1797 
1798     return(error);
1799 }
1800 
1801 /************************************************************************
1802  * Get status for a logical drive.
1803  *
1804  * XXX should we also do this in response to Test Unit Ready?
1805  */
1806 static int
1807 ciss_get_ldrive_status(struct ciss_softc *sc,  struct ciss_ldrive *ld)
1808 {
1809     struct ciss_request		*cr;
1810     struct ciss_command		*cc;
1811     struct ciss_bmic_cdb	*cbc;
1812     int				error, command_status;
1813 
1814     /*
1815      * Build a CISS BMIC command to get the logical drive status.
1816      */
1817     if ((error = ciss_get_bmic_request(sc, &cr, CISS_BMIC_ID_LSTATUS,
1818 				       (void **)&ld->cl_lstatus,
1819 				       sizeof(*ld->cl_lstatus))) != 0)
1820 	goto out;
1821     cc = cr->cr_cc;
1822     cc->header.address = *ld->cl_controller;	/* target controller */
1823     cbc = (struct ciss_bmic_cdb *)&(cc->cdb.cdb[0]);
1824     cbc->log_drive = CISS_LUN_TO_TARGET(ld->cl_address.logical.lun);
1825 
1826     /*
1827      * Submit the request and wait for it to complete.
1828      */
1829     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
1830 	ciss_printf(sc, "error sending BMIC LSTATUS command (%d)\n", error);
1831 	goto out;
1832     }
1833 
1834     /*
1835      * Check response.
1836      */
1837     ciss_report_request(cr, &command_status, NULL);
1838     switch(command_status) {
1839     case CISS_CMD_STATUS_SUCCESS:		/* buffer right size */
1840 	break;
1841     case CISS_CMD_STATUS_DATA_UNDERRUN:
1842     case CISS_CMD_STATUS_DATA_OVERRUN:
1843 	ciss_printf(sc, "data over/underrun reading logical drive status\n");
1844     default:
1845 	ciss_printf(sc, "error reading logical drive status (%s)\n",
1846 		    ciss_name_command_status(command_status));
1847 	error = EIO;
1848 	goto out;
1849     }
1850 
1851     /*
1852      * Set the drive's summary status based on the returned status.
1853      *
1854      * XXX testing shows that a failed JBOD drive comes back at next
1855      * boot in "queued for expansion" mode.  WTF?
1856      */
1857     ld->cl_status = ciss_decode_ldrive_status(ld->cl_lstatus->status);
1858 
1859 out:
1860     if (cr != NULL)
1861 	ciss_release_request(cr);
1862     return(error);
1863 }
1864 
1865 /************************************************************************
1866  * Notify the adapter of a config update.
1867  */
1868 static int
1869 ciss_update_config(struct ciss_softc *sc)
1870 {
1871     int		i;
1872 
1873     debug_called(1);
1874 
1875     CISS_TL_SIMPLE_WRITE(sc, CISS_TL_SIMPLE_IDBR, CISS_TL_SIMPLE_IDBR_CFG_TABLE);
1876     for (i = 0; i < 1000; i++) {
1877 	if (!(CISS_TL_SIMPLE_READ(sc, CISS_TL_SIMPLE_IDBR) &
1878 	      CISS_TL_SIMPLE_IDBR_CFG_TABLE)) {
1879 	    return(0);
1880 	}
1881 	DELAY(1000);
1882     }
1883     return(1);
1884 }
1885 
1886 /************************************************************************
1887  * Accept new media into a logical drive.
1888  *
1889  * XXX The drive has previously been offline; it would be good if we
1890  *     could make sure it's not open right now.
1891  */
1892 static int
1893 ciss_accept_media(struct ciss_softc *sc, struct ciss_ldrive *ld)
1894 {
1895     struct ciss_request		*cr;
1896     struct ciss_command		*cc;
1897     struct ciss_bmic_cdb	*cbc;
1898     int				command_status;
1899     int				error = 0, ldrive;
1900 
1901     ldrive = CISS_LUN_TO_TARGET(ld->cl_address.logical.lun);
1902 
1903     debug(0, "bringing logical drive %d back online", ldrive);
1904 
1905     /*
1906      * Build a CISS BMIC command to bring the drive back online.
1907      */
1908     if ((error = ciss_get_bmic_request(sc, &cr, CISS_BMIC_ACCEPT_MEDIA,
1909 				       NULL, 0)) != 0)
1910 	goto out;
1911     cc = cr->cr_cc;
1912     cc->header.address = *ld->cl_controller;	/* target controller */
1913     cbc = (struct ciss_bmic_cdb *)&(cc->cdb.cdb[0]);
1914     cbc->log_drive = ldrive;
1915 
1916     /*
1917      * Submit the request and wait for it to complete.
1918      */
1919     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
1920 	ciss_printf(sc, "error sending BMIC ACCEPT MEDIA command (%d)\n", error);
1921 	goto out;
1922     }
1923 
1924     /*
1925      * Check response.
1926      */
1927     ciss_report_request(cr, &command_status, NULL);
1928     switch(command_status) {
1929     case CISS_CMD_STATUS_SUCCESS:		/* all OK */
1930 	/* we should get a logical drive status changed event here */
1931 	break;
1932     default:
1933 	ciss_printf(cr->cr_sc, "error accepting media into failed logical drive (%s)\n",
1934 		    ciss_name_command_status(command_status));
1935 	break;
1936     }
1937 
1938 out:
1939     if (cr != NULL)
1940 	ciss_release_request(cr);
1941     return(error);
1942 }
1943 
1944 /************************************************************************
1945  * Release adapter resources.
1946  */
1947 static void
1948 ciss_free(struct ciss_softc *sc)
1949 {
1950     struct ciss_request *cr;
1951     int			i, j;
1952 
1953     debug_called(1);
1954 
1955     /* we're going away */
1956     sc->ciss_flags |= CISS_FLAG_ABORTING;
1957 
1958     /* terminate the periodic heartbeat routine */
1959     callout_stop(&sc->ciss_periodic);
1960 
1961     /* cancel the Event Notify chain */
1962     ciss_notify_abort(sc);
1963 
1964     ciss_kill_notify_thread(sc);
1965 
1966     /* disconnect from CAM */
1967     if (sc->ciss_cam_sim) {
1968 	for (i = 0; i < sc->ciss_max_logical_bus; i++) {
1969 	    if (sc->ciss_cam_sim[i]) {
1970 		xpt_bus_deregister(cam_sim_path(sc->ciss_cam_sim[i]));
1971 		cam_sim_free(sc->ciss_cam_sim[i], 0);
1972 	    }
1973 	}
1974 	for (i = CISS_PHYSICAL_BASE; i < sc->ciss_max_physical_bus +
1975 	     CISS_PHYSICAL_BASE; i++) {
1976 	    if (sc->ciss_cam_sim[i]) {
1977 		xpt_bus_deregister(cam_sim_path(sc->ciss_cam_sim[i]));
1978 		cam_sim_free(sc->ciss_cam_sim[i], 0);
1979 	    }
1980 	}
1981 	free(sc->ciss_cam_sim, CISS_MALLOC_CLASS);
1982     }
1983     if (sc->ciss_cam_devq)
1984 	cam_simq_free(sc->ciss_cam_devq);
1985 
1986     /* remove the control device */
1987     mtx_unlock(&sc->ciss_mtx);
1988     if (sc->ciss_dev_t != NULL)
1989 	destroy_dev(sc->ciss_dev_t);
1990 
1991     /* Final cleanup of the callout. */
1992     callout_drain(&sc->ciss_periodic);
1993     mtx_destroy(&sc->ciss_mtx);
1994 
1995     /* free the controller data */
1996     if (sc->ciss_id != NULL)
1997 	free(sc->ciss_id, CISS_MALLOC_CLASS);
1998 
1999     /* release I/O resources */
2000     if (sc->ciss_regs_resource != NULL)
2001 	bus_release_resource(sc->ciss_dev, SYS_RES_MEMORY,
2002 			     sc->ciss_regs_rid, sc->ciss_regs_resource);
2003     if (sc->ciss_cfg_resource != NULL)
2004 	bus_release_resource(sc->ciss_dev, SYS_RES_MEMORY,
2005 			     sc->ciss_cfg_rid, sc->ciss_cfg_resource);
2006     if (sc->ciss_intr != NULL)
2007 	bus_teardown_intr(sc->ciss_dev, sc->ciss_irq_resource, sc->ciss_intr);
2008     if (sc->ciss_irq_resource != NULL)
2009 	bus_release_resource(sc->ciss_dev, SYS_RES_IRQ,
2010 			     sc->ciss_irq_rid[0], sc->ciss_irq_resource);
2011     if (sc->ciss_msi)
2012 	pci_release_msi(sc->ciss_dev);
2013 
2014     while ((cr = ciss_dequeue_free(sc)) != NULL)
2015 	bus_dmamap_destroy(sc->ciss_buffer_dmat, cr->cr_datamap);
2016     if (sc->ciss_buffer_dmat)
2017 	bus_dma_tag_destroy(sc->ciss_buffer_dmat);
2018 
2019     /* destroy command memory and DMA tag */
2020     if (sc->ciss_command != NULL) {
2021 	bus_dmamap_unload(sc->ciss_command_dmat, sc->ciss_command_map);
2022 	bus_dmamem_free(sc->ciss_command_dmat, sc->ciss_command, sc->ciss_command_map);
2023     }
2024     if (sc->ciss_command_dmat)
2025 	bus_dma_tag_destroy(sc->ciss_command_dmat);
2026 
2027     if (sc->ciss_reply) {
2028 	bus_dmamap_unload(sc->ciss_reply_dmat, sc->ciss_reply_map);
2029 	bus_dmamem_free(sc->ciss_reply_dmat, sc->ciss_reply, sc->ciss_reply_map);
2030     }
2031     if (sc->ciss_reply_dmat)
2032 	bus_dma_tag_destroy(sc->ciss_reply_dmat);
2033 
2034     /* destroy DMA tags */
2035     if (sc->ciss_parent_dmat)
2036 	bus_dma_tag_destroy(sc->ciss_parent_dmat);
2037     if (sc->ciss_logical) {
2038 	for (i = 0; i < sc->ciss_max_logical_bus; i++) {
2039 	    for (j = 0; j < sc->ciss_cfg->max_logical_supported; j++) {
2040 		if (sc->ciss_logical[i][j].cl_ldrive)
2041 		    free(sc->ciss_logical[i][j].cl_ldrive, CISS_MALLOC_CLASS);
2042 		if (sc->ciss_logical[i][j].cl_lstatus)
2043 		    free(sc->ciss_logical[i][j].cl_lstatus, CISS_MALLOC_CLASS);
2044 	    }
2045 	    free(sc->ciss_logical[i], CISS_MALLOC_CLASS);
2046 	}
2047 	free(sc->ciss_logical, CISS_MALLOC_CLASS);
2048     }
2049 
2050     if (sc->ciss_physical) {
2051 	for (i = 0; i < sc->ciss_max_physical_bus; i++)
2052 	    free(sc->ciss_physical[i], CISS_MALLOC_CLASS);
2053 	free(sc->ciss_physical, CISS_MALLOC_CLASS);
2054     }
2055 
2056     if (sc->ciss_controllers)
2057 	free(sc->ciss_controllers, CISS_MALLOC_CLASS);
2058 
2059 }
2060 
2061 /************************************************************************
2062  * Give a command to the adapter.
2063  *
2064  * Note that this uses the simple transport layer directly.  If we
2065  * want to add support for other layers, we'll need a switch of some
2066  * sort.
2067  *
2068  * Note that the simple transport layer has no way of refusing a
2069  * command; we only have as many request structures as the adapter
2070  * supports commands, so we don't have to check (this presumes that
2071  * the adapter can handle commands as fast as we throw them at it).
2072  */
2073 static int
2074 ciss_start(struct ciss_request *cr)
2075 {
2076     int			error;
2077 
2078     debug(2, "post command %d tag %d ", cr->cr_tag, cr->cr_cc->header.host_tag);
2079 
2080     /*
2081      * Map the request's data.
2082      */
2083     if ((error = ciss_map_request(cr)))
2084 	return(error);
2085 
2086 #if 0
2087     ciss_print_request(cr);
2088 #endif
2089 
2090     return(0);
2091 }
2092 
2093 /************************************************************************
2094  * Fetch completed request(s) from the adapter, queue them for
2095  * completion handling.
2096  *
2097  * Note that this uses the simple transport layer directly.  If we
2098  * want to add support for other layers, we'll need a switch of some
2099  * sort.
2100  *
2101  * Note that the simple transport mechanism does not require any
2102  * reentrancy protection; the OPQ read is atomic.  If there is a
2103  * chance of a race with something else that might move the request
2104  * off the busy list, then we will have to lock against that
2105  * (eg. timeouts, etc.)
2106  */
2107 static void
2108 ciss_done(struct ciss_softc *sc, cr_qhead_t *qh)
2109 {
2110     struct ciss_request	*cr;
2111     struct ciss_command	*cc;
2112     u_int32_t		tag, index;
2113 
2114     debug_called(3);
2115 
2116     /*
2117      * Loop quickly taking requests from the adapter and moving them
2118      * to the completed queue.
2119      */
2120     for (;;) {
2121 	tag = CISS_TL_SIMPLE_FETCH_CMD(sc);
2122 	if (tag == CISS_TL_SIMPLE_OPQ_EMPTY)
2123 	    break;
2124 	index = tag >> 2;
2125 	debug(2, "completed command %d%s", index,
2126 	      (tag & CISS_HDR_HOST_TAG_ERROR) ? " with error" : "");
2127 	if (index >= sc->ciss_max_requests) {
2128 	    ciss_printf(sc, "completed invalid request %d (0x%x)\n", index, tag);
2129 	    continue;
2130 	}
2131 	cr = &(sc->ciss_request[index]);
2132 	cc = cr->cr_cc;
2133 	cc->header.host_tag = tag;	/* not updated by adapter */
2134 	ciss_enqueue_complete(cr, qh);
2135     }
2136 
2137 }
2138 
2139 static void
2140 ciss_perf_done(struct ciss_softc *sc, cr_qhead_t *qh)
2141 {
2142     struct ciss_request	*cr;
2143     struct ciss_command	*cc;
2144     u_int32_t		tag, index;
2145 
2146     debug_called(3);
2147 
2148     /*
2149      * Loop quickly taking requests from the adapter and moving them
2150      * to the completed queue.
2151      */
2152     for (;;) {
2153 	tag = sc->ciss_reply[sc->ciss_rqidx];
2154 	if ((tag & CISS_CYCLE_MASK) != sc->ciss_cycle)
2155 	    break;
2156 	index = tag >> 2;
2157 	debug(2, "completed command %d%s\n", index,
2158 	      (tag & CISS_HDR_HOST_TAG_ERROR) ? " with error" : "");
2159 	if (index < sc->ciss_max_requests) {
2160 	    cr = &(sc->ciss_request[index]);
2161 	    cc = cr->cr_cc;
2162 	    cc->header.host_tag = tag;	/* not updated by adapter */
2163 	    ciss_enqueue_complete(cr, qh);
2164 	} else {
2165 	    ciss_printf(sc, "completed invalid request %d (0x%x)\n", index, tag);
2166 	}
2167 	if (++sc->ciss_rqidx == sc->ciss_max_requests) {
2168 	    sc->ciss_rqidx = 0;
2169 	    sc->ciss_cycle ^= 1;
2170 	}
2171     }
2172 
2173 }
2174 
2175 /************************************************************************
2176  * Take an interrupt from the adapter.
2177  */
2178 static void
2179 ciss_intr(void *arg)
2180 {
2181     cr_qhead_t qh;
2182     struct ciss_softc	*sc = (struct ciss_softc *)arg;
2183 
2184     /*
2185      * The only interrupt we recognise indicates that there are
2186      * entries in the outbound post queue.
2187      */
2188     STAILQ_INIT(&qh);
2189     ciss_done(sc, &qh);
2190     mtx_lock(&sc->ciss_mtx);
2191     ciss_complete(sc, &qh);
2192     mtx_unlock(&sc->ciss_mtx);
2193 }
2194 
2195 static void
2196 ciss_perf_intr(void *arg)
2197 {
2198     struct ciss_softc	*sc = (struct ciss_softc *)arg;
2199 
2200     /* Clear the interrupt and flush the bridges.  Docs say that the flush
2201      * needs to be done twice, which doesn't seem right.
2202      */
2203     CISS_TL_PERF_CLEAR_INT(sc);
2204     CISS_TL_PERF_FLUSH_INT(sc);
2205 
2206     ciss_perf_msi_intr(sc);
2207 }
2208 
2209 static void
2210 ciss_perf_msi_intr(void *arg)
2211 {
2212     cr_qhead_t qh;
2213     struct ciss_softc	*sc = (struct ciss_softc *)arg;
2214 
2215     STAILQ_INIT(&qh);
2216     ciss_perf_done(sc, &qh);
2217     mtx_lock(&sc->ciss_mtx);
2218     ciss_complete(sc, &qh);
2219     mtx_unlock(&sc->ciss_mtx);
2220 }
2221 
2222 /************************************************************************
2223  * Process completed requests.
2224  *
2225  * Requests can be completed in three fashions:
2226  *
2227  * - by invoking a callback function (cr_complete is non-null)
2228  * - by waking up a sleeper (cr_flags has CISS_REQ_SLEEP set)
2229  * - by clearing the CISS_REQ_POLL flag in interrupt/timeout context
2230  */
2231 static void
2232 ciss_complete(struct ciss_softc *sc, cr_qhead_t *qh)
2233 {
2234     struct ciss_request	*cr;
2235 
2236     debug_called(2);
2237 
2238     /*
2239      * Loop taking requests off the completed queue and performing
2240      * completion processing on them.
2241      */
2242     for (;;) {
2243 	if ((cr = ciss_dequeue_complete(sc, qh)) == NULL)
2244 	    break;
2245 	ciss_unmap_request(cr);
2246 
2247 	if ((cr->cr_flags & CISS_REQ_BUSY) == 0)
2248 	    ciss_printf(sc, "WARNING: completing non-busy request\n");
2249 	cr->cr_flags &= ~CISS_REQ_BUSY;
2250 
2251 	/*
2252 	 * If the request has a callback, invoke it.
2253 	 */
2254 	if (cr->cr_complete != NULL) {
2255 	    cr->cr_complete(cr);
2256 	    continue;
2257 	}
2258 
2259 	/*
2260 	 * If someone is sleeping on this request, wake them up.
2261 	 */
2262 	if (cr->cr_flags & CISS_REQ_SLEEP) {
2263 	    cr->cr_flags &= ~CISS_REQ_SLEEP;
2264 	    wakeup(cr);
2265 	    continue;
2266 	}
2267 
2268 	/*
2269 	 * If someone is polling this request for completion, signal.
2270 	 */
2271 	if (cr->cr_flags & CISS_REQ_POLL) {
2272 	    cr->cr_flags &= ~CISS_REQ_POLL;
2273 	    continue;
2274 	}
2275 
2276 	/*
2277 	 * Give up and throw the request back on the free queue.  This
2278 	 * should never happen; resources will probably be lost.
2279 	 */
2280 	ciss_printf(sc, "WARNING: completed command with no submitter\n");
2281 	ciss_enqueue_free(cr);
2282     }
2283 }
2284 
2285 /************************************************************************
2286  * Report on the completion status of a request, and pass back SCSI
2287  * and command status values.
2288  */
2289 static int
2290 _ciss_report_request(struct ciss_request *cr, int *command_status, int *scsi_status, const char *func)
2291 {
2292     struct ciss_command		*cc;
2293     struct ciss_error_info	*ce;
2294 
2295     debug_called(2);
2296 
2297     cc = cr->cr_cc;
2298     ce = (struct ciss_error_info *)&(cc->sg[0]);
2299 
2300     /*
2301      * We don't consider data under/overrun an error for the Report
2302      * Logical/Physical LUNs commands.
2303      */
2304     if ((cc->header.host_tag & CISS_HDR_HOST_TAG_ERROR) &&
2305 	((ce->command_status == CISS_CMD_STATUS_DATA_OVERRUN) ||
2306 	 (ce->command_status == CISS_CMD_STATUS_DATA_UNDERRUN)) &&
2307 	((cc->cdb.cdb[0] == CISS_OPCODE_REPORT_LOGICAL_LUNS) ||
2308 	 (cc->cdb.cdb[0] == CISS_OPCODE_REPORT_PHYSICAL_LUNS) ||
2309 	 (cc->cdb.cdb[0] == INQUIRY))) {
2310 	cc->header.host_tag &= ~CISS_HDR_HOST_TAG_ERROR;
2311 	debug(2, "ignoring irrelevant under/overrun error");
2312     }
2313 
2314     /*
2315      * Check the command's error bit, if clear, there's no status and
2316      * everything is OK.
2317      */
2318     if (!(cc->header.host_tag & CISS_HDR_HOST_TAG_ERROR)) {
2319 	if (scsi_status != NULL)
2320 	    *scsi_status = SCSI_STATUS_OK;
2321 	if (command_status != NULL)
2322 	    *command_status = CISS_CMD_STATUS_SUCCESS;
2323 	return(0);
2324     } else {
2325 	if (command_status != NULL)
2326 	    *command_status = ce->command_status;
2327 	if (scsi_status != NULL) {
2328 	    if (ce->command_status == CISS_CMD_STATUS_DATA_UNDERRUN) {
2329 		*scsi_status = SCSI_STATUS_OK;
2330 	    } else if (ce->command_status == CISS_CMD_STATUS_TARGET_STATUS) {
2331 		*scsi_status = ce->scsi_status;
2332 	    } else {
2333 		*scsi_status = -1;
2334 	    }
2335 	}
2336 	if (bootverbose && ce->command_status != CISS_CMD_STATUS_DATA_UNDERRUN)
2337 	    ciss_printf(cr->cr_sc, "command status 0x%x (%s) scsi status 0x%x\n",
2338 			ce->command_status, ciss_name_command_status(ce->command_status),
2339 			ce->scsi_status);
2340 	if (ce->command_status == CISS_CMD_STATUS_INVALID_COMMAND) {
2341 	    ciss_printf(cr->cr_sc, "invalid command, offense size %d at %d, value 0x%x, function %s\n",
2342 			ce->additional_error_info.invalid_command.offense_size,
2343 			ce->additional_error_info.invalid_command.offense_offset,
2344 			ce->additional_error_info.invalid_command.offense_value,
2345 			func);
2346 	}
2347     }
2348 #if 0
2349     ciss_print_request(cr);
2350 #endif
2351     return(1);
2352 }
2353 
2354 /************************************************************************
2355  * Issue a request and don't return until it's completed.
2356  *
2357  * Depending on adapter status, we may poll or sleep waiting for
2358  * completion.
2359  */
2360 static int
2361 ciss_synch_request(struct ciss_request *cr, int timeout)
2362 {
2363     if (cr->cr_sc->ciss_flags & CISS_FLAG_RUNNING) {
2364 	return(ciss_wait_request(cr, timeout));
2365     } else {
2366 	return(ciss_poll_request(cr, timeout));
2367     }
2368 }
2369 
2370 /************************************************************************
2371  * Issue a request and poll for completion.
2372  *
2373  * Timeout in milliseconds.
2374  */
2375 static int
2376 ciss_poll_request(struct ciss_request *cr, int timeout)
2377 {
2378     cr_qhead_t qh;
2379     struct ciss_softc *sc;
2380     int		error;
2381 
2382     debug_called(2);
2383 
2384     STAILQ_INIT(&qh);
2385     sc = cr->cr_sc;
2386     cr->cr_flags |= CISS_REQ_POLL;
2387     if ((error = ciss_start(cr)) != 0)
2388 	return(error);
2389 
2390     do {
2391 	if (sc->ciss_perf)
2392 	    ciss_perf_done(sc, &qh);
2393 	else
2394 	    ciss_done(sc, &qh);
2395 	ciss_complete(sc, &qh);
2396 	if (!(cr->cr_flags & CISS_REQ_POLL))
2397 	    return(0);
2398 	DELAY(1000);
2399     } while (timeout-- >= 0);
2400     return(EWOULDBLOCK);
2401 }
2402 
2403 /************************************************************************
2404  * Issue a request and sleep waiting for completion.
2405  *
2406  * Timeout in milliseconds.  Note that a spurious wakeup will reset
2407  * the timeout.
2408  */
2409 static int
2410 ciss_wait_request(struct ciss_request *cr, int timeout)
2411 {
2412     int		error;
2413 
2414     debug_called(2);
2415 
2416     cr->cr_flags |= CISS_REQ_SLEEP;
2417     if ((error = ciss_start(cr)) != 0)
2418 	return(error);
2419 
2420     while ((cr->cr_flags & CISS_REQ_SLEEP) && (error != EWOULDBLOCK)) {
2421 	error = msleep_sbt(cr, &cr->cr_sc->ciss_mtx, PRIBIO, "cissREQ",
2422 	    SBT_1MS * timeout, 0, 0);
2423     }
2424     return(error);
2425 }
2426 
2427 #if 0
2428 /************************************************************************
2429  * Abort a request.  Note that a potential exists here to race the
2430  * request being completed; the caller must deal with this.
2431  */
2432 static int
2433 ciss_abort_request(struct ciss_request *ar)
2434 {
2435     struct ciss_request		*cr;
2436     struct ciss_command		*cc;
2437     struct ciss_message_cdb	*cmc;
2438     int				error;
2439 
2440     debug_called(1);
2441 
2442     /* get a request */
2443     if ((error = ciss_get_request(ar->cr_sc, &cr)) != 0)
2444 	return(error);
2445 
2446     /* build the abort command */
2447     cc = cr->cr_cc;
2448     cc->header.address.mode.mode = CISS_HDR_ADDRESS_MODE_PERIPHERAL;	/* addressing? */
2449     cc->header.address.physical.target = 0;
2450     cc->header.address.physical.bus = 0;
2451     cc->cdb.cdb_length = sizeof(*cmc);
2452     cc->cdb.type = CISS_CDB_TYPE_MESSAGE;
2453     cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;
2454     cc->cdb.direction = CISS_CDB_DIRECTION_NONE;
2455     cc->cdb.timeout = 30;
2456 
2457     cmc = (struct ciss_message_cdb *)&(cc->cdb.cdb[0]);
2458     cmc->opcode = CISS_OPCODE_MESSAGE_ABORT;
2459     cmc->type = CISS_MESSAGE_ABORT_TASK;
2460     cmc->abort_tag = ar->cr_tag;	/* endianness?? */
2461 
2462     /*
2463      * Send the request and wait for a response.  If we believe we
2464      * aborted the request OK, clear the flag that indicates it's
2465      * running.
2466      */
2467     error = ciss_synch_request(cr, 35 * 1000);
2468     if (!error)
2469 	error = ciss_report_request(cr, NULL, NULL);
2470     ciss_release_request(cr);
2471 
2472     return(error);
2473 }
2474 #endif
2475 
2476 /************************************************************************
2477  * Fetch and initialise a request
2478  */
2479 static int
2480 ciss_get_request(struct ciss_softc *sc, struct ciss_request **crp)
2481 {
2482     struct ciss_request *cr;
2483 
2484     debug_called(2);
2485 
2486     /*
2487      * Get a request and clean it up.
2488      */
2489     if ((cr = ciss_dequeue_free(sc)) == NULL)
2490 	return(ENOMEM);
2491 
2492     cr->cr_data = NULL;
2493     cr->cr_flags = 0;
2494     cr->cr_complete = NULL;
2495     cr->cr_private = NULL;
2496     cr->cr_sg_tag = CISS_SG_MAX;	/* Backstop to prevent accidents */
2497 
2498     ciss_preen_command(cr);
2499     *crp = cr;
2500     return(0);
2501 }
2502 
2503 static void
2504 ciss_preen_command(struct ciss_request *cr)
2505 {
2506     struct ciss_command	*cc;
2507     u_int32_t		cmdphys;
2508 
2509     /*
2510      * Clean up the command structure.
2511      *
2512      * Note that we set up the error_info structure here, since the
2513      * length can be overwritten by any command.
2514      */
2515     cc = cr->cr_cc;
2516     cc->header.sg_in_list = 0;		/* kinda inefficient this way */
2517     cc->header.sg_total = 0;
2518     cc->header.host_tag = cr->cr_tag << 2;
2519     cc->header.host_tag_zeroes = 0;
2520     bzero(&(cc->sg[0]), CISS_COMMAND_ALLOC_SIZE - sizeof(struct ciss_command));
2521     cmdphys = cr->cr_ccphys;
2522     cc->error_info.error_info_address = cmdphys + sizeof(struct ciss_command);
2523     cc->error_info.error_info_length = CISS_COMMAND_ALLOC_SIZE - sizeof(struct ciss_command);
2524 }
2525 
2526 /************************************************************************
2527  * Release a request to the free list.
2528  */
2529 static void
2530 ciss_release_request(struct ciss_request *cr)
2531 {
2532 
2533     debug_called(2);
2534 
2535     /* release the request to the free queue */
2536     ciss_requeue_free(cr);
2537 }
2538 
2539 /************************************************************************
2540  * Allocate a request that will be used to send a BMIC command.  Do some
2541  * of the common setup here to avoid duplicating it everywhere else.
2542  */
2543 static int
2544 ciss_get_bmic_request(struct ciss_softc *sc, struct ciss_request **crp,
2545 		      int opcode, void **bufp, size_t bufsize)
2546 {
2547     struct ciss_request		*cr;
2548     struct ciss_command		*cc;
2549     struct ciss_bmic_cdb	*cbc;
2550     void			*buf;
2551     int				error;
2552     int				dataout;
2553 
2554     debug_called(2);
2555 
2556     cr = NULL;
2557     buf = NULL;
2558 
2559     /*
2560      * Get a request.
2561      */
2562     if ((error = ciss_get_request(sc, &cr)) != 0)
2563 	goto out;
2564 
2565     /*
2566      * Allocate data storage if requested, determine the data direction.
2567      */
2568     dataout = 0;
2569     if ((bufsize > 0) && (bufp != NULL)) {
2570 	if (*bufp == NULL) {
2571 	    if ((buf = malloc(bufsize, CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO)) == NULL) {
2572 		error = ENOMEM;
2573 		goto out;
2574 	    }
2575 	} else {
2576 	    buf = *bufp;
2577 	    dataout = 1;	/* we are given a buffer, so we are writing */
2578 	}
2579     }
2580 
2581     /*
2582      * Build a CISS BMIC command to get the logical drive ID.
2583      */
2584     cr->cr_data = buf;
2585     cr->cr_length = bufsize;
2586     if (!dataout)
2587 	cr->cr_flags = CISS_REQ_DATAIN;
2588 
2589     cc = cr->cr_cc;
2590     cc->header.address.physical.mode = CISS_HDR_ADDRESS_MODE_PERIPHERAL;
2591     cc->header.address.physical.bus = 0;
2592     cc->header.address.physical.target = 0;
2593     cc->cdb.cdb_length = sizeof(*cbc);
2594     cc->cdb.type = CISS_CDB_TYPE_COMMAND;
2595     cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;
2596     cc->cdb.direction = dataout ? CISS_CDB_DIRECTION_WRITE : CISS_CDB_DIRECTION_READ;
2597     cc->cdb.timeout = 0;
2598 
2599     cbc = (struct ciss_bmic_cdb *)&(cc->cdb.cdb[0]);
2600     bzero(cbc, sizeof(*cbc));
2601     cbc->opcode = dataout ? CISS_ARRAY_CONTROLLER_WRITE : CISS_ARRAY_CONTROLLER_READ;
2602     cbc->bmic_opcode = opcode;
2603     cbc->size = htons((u_int16_t)bufsize);
2604 
2605 out:
2606     if (error) {
2607 	if (cr != NULL)
2608 	    ciss_release_request(cr);
2609     } else {
2610 	*crp = cr;
2611 	if ((bufp != NULL) && (*bufp == NULL) && (buf != NULL))
2612 	    *bufp = buf;
2613     }
2614     return(error);
2615 }
2616 
2617 /************************************************************************
2618  * Handle a command passed in from userspace.
2619  */
2620 static int
2621 ciss_user_command(struct ciss_softc *sc, IOCTL_Command_struct *ioc)
2622 {
2623     struct ciss_request		*cr;
2624     struct ciss_command		*cc;
2625     struct ciss_error_info	*ce;
2626     int				error = 0;
2627 
2628     debug_called(1);
2629 
2630     cr = NULL;
2631 
2632     /*
2633      * Get a request.
2634      */
2635     while (ciss_get_request(sc, &cr) != 0)
2636 	msleep(sc, &sc->ciss_mtx, PPAUSE, "cissREQ", hz);
2637     cc = cr->cr_cc;
2638 
2639     /*
2640      * Allocate an in-kernel databuffer if required, copy in user data.
2641      */
2642     mtx_unlock(&sc->ciss_mtx);
2643     cr->cr_length = ioc->buf_size;
2644     if (ioc->buf_size > 0) {
2645 	if ((cr->cr_data = malloc(ioc->buf_size, CISS_MALLOC_CLASS, M_NOWAIT)) == NULL) {
2646 	    error = ENOMEM;
2647 	    goto out_unlocked;
2648 	}
2649 	if ((error = copyin(ioc->buf, cr->cr_data, ioc->buf_size))) {
2650 	    debug(0, "copyin: bad data buffer %p/%d", ioc->buf, ioc->buf_size);
2651 	    goto out_unlocked;
2652 	}
2653     }
2654 
2655     /*
2656      * Build the request based on the user command.
2657      */
2658     bcopy(&ioc->LUN_info, &cc->header.address, sizeof(cc->header.address));
2659     bcopy(&ioc->Request, &cc->cdb, sizeof(cc->cdb));
2660 
2661     /* XXX anything else to populate here? */
2662     mtx_lock(&sc->ciss_mtx);
2663 
2664     /*
2665      * Run the command.
2666      */
2667     if ((error = ciss_synch_request(cr, 60 * 1000))) {
2668 	debug(0, "request failed - %d", error);
2669 	goto out;
2670     }
2671 
2672     /*
2673      * Check to see if the command succeeded.
2674      */
2675     ce = (struct ciss_error_info *)&(cc->sg[0]);
2676     if ((cc->header.host_tag & CISS_HDR_HOST_TAG_ERROR) == 0)
2677 	bzero(ce, sizeof(*ce));
2678 
2679     /*
2680      * Copy the results back to the user.
2681      */
2682     bcopy(ce, &ioc->error_info, sizeof(*ce));
2683     mtx_unlock(&sc->ciss_mtx);
2684     if ((ioc->buf_size > 0) &&
2685 	(error = copyout(cr->cr_data, ioc->buf, ioc->buf_size))) {
2686 	debug(0, "copyout: bad data buffer %p/%d", ioc->buf, ioc->buf_size);
2687 	goto out_unlocked;
2688     }
2689 
2690     /* done OK */
2691     error = 0;
2692 
2693 out_unlocked:
2694     mtx_lock(&sc->ciss_mtx);
2695 
2696 out:
2697     if ((cr != NULL) && (cr->cr_data != NULL))
2698 	free(cr->cr_data, CISS_MALLOC_CLASS);
2699     if (cr != NULL)
2700 	ciss_release_request(cr);
2701     return(error);
2702 }
2703 
2704 /************************************************************************
2705  * Map a request into bus-visible space, initialise the scatter/gather
2706  * list.
2707  */
2708 static int
2709 ciss_map_request(struct ciss_request *cr)
2710 {
2711     struct ciss_softc	*sc;
2712     int			error = 0;
2713 
2714     debug_called(2);
2715 
2716     sc = cr->cr_sc;
2717 
2718     /* check that mapping is necessary */
2719     if (cr->cr_flags & CISS_REQ_MAPPED)
2720 	return(0);
2721 
2722     cr->cr_flags |= CISS_REQ_MAPPED;
2723 
2724     bus_dmamap_sync(sc->ciss_command_dmat, sc->ciss_command_map,
2725 		    BUS_DMASYNC_PREWRITE);
2726 
2727     if (cr->cr_data != NULL) {
2728 	if (cr->cr_flags & CISS_REQ_CCB)
2729 		error = bus_dmamap_load_ccb(sc->ciss_buffer_dmat,
2730 					cr->cr_datamap, cr->cr_data,
2731 					ciss_request_map_helper, cr, 0);
2732 	else
2733 		error = bus_dmamap_load(sc->ciss_buffer_dmat, cr->cr_datamap,
2734 					cr->cr_data, cr->cr_length,
2735 					ciss_request_map_helper, cr, 0);
2736 	if (error != 0)
2737 	    return (error);
2738     } else {
2739 	/*
2740 	 * Post the command to the adapter.
2741 	 */
2742 	cr->cr_sg_tag = CISS_SG_NONE;
2743 	cr->cr_flags |= CISS_REQ_BUSY;
2744 	if (sc->ciss_perf)
2745 	    CISS_TL_PERF_POST_CMD(sc, cr);
2746 	else
2747 	    CISS_TL_SIMPLE_POST_CMD(sc, cr->cr_ccphys);
2748     }
2749 
2750     return(0);
2751 }
2752 
2753 static void
2754 ciss_request_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
2755 {
2756     struct ciss_command	*cc;
2757     struct ciss_request *cr;
2758     struct ciss_softc	*sc;
2759     int			i;
2760 
2761     debug_called(2);
2762 
2763     cr = (struct ciss_request *)arg;
2764     sc = cr->cr_sc;
2765     cc = cr->cr_cc;
2766 
2767     for (i = 0; i < nseg; i++) {
2768 	cc->sg[i].address = segs[i].ds_addr;
2769 	cc->sg[i].length = segs[i].ds_len;
2770 	cc->sg[i].extension = 0;
2771     }
2772     /* we leave the s/g table entirely within the command */
2773     cc->header.sg_in_list = nseg;
2774     cc->header.sg_total = nseg;
2775 
2776     if (cr->cr_flags & CISS_REQ_DATAIN)
2777 	bus_dmamap_sync(sc->ciss_buffer_dmat, cr->cr_datamap, BUS_DMASYNC_PREREAD);
2778     if (cr->cr_flags & CISS_REQ_DATAOUT)
2779 	bus_dmamap_sync(sc->ciss_buffer_dmat, cr->cr_datamap, BUS_DMASYNC_PREWRITE);
2780 
2781     if (nseg == 0)
2782 	cr->cr_sg_tag = CISS_SG_NONE;
2783     else if (nseg == 1)
2784 	cr->cr_sg_tag = CISS_SG_1;
2785     else if (nseg == 2)
2786 	cr->cr_sg_tag = CISS_SG_2;
2787     else if (nseg <= 4)
2788 	cr->cr_sg_tag = CISS_SG_4;
2789     else if (nseg <= 8)
2790 	cr->cr_sg_tag = CISS_SG_8;
2791     else if (nseg <= 16)
2792 	cr->cr_sg_tag = CISS_SG_16;
2793     else if (nseg <= 32)
2794 	cr->cr_sg_tag = CISS_SG_32;
2795     else
2796 	cr->cr_sg_tag = CISS_SG_MAX;
2797 
2798     /*
2799      * Post the command to the adapter.
2800      */
2801     cr->cr_flags |= CISS_REQ_BUSY;
2802     if (sc->ciss_perf)
2803 	CISS_TL_PERF_POST_CMD(sc, cr);
2804     else
2805 	CISS_TL_SIMPLE_POST_CMD(sc, cr->cr_ccphys);
2806 }
2807 
2808 /************************************************************************
2809  * Unmap a request from bus-visible space.
2810  */
2811 static void
2812 ciss_unmap_request(struct ciss_request *cr)
2813 {
2814     struct ciss_softc	*sc;
2815 
2816     debug_called(2);
2817 
2818     sc = cr->cr_sc;
2819 
2820     /* check that unmapping is necessary */
2821     if ((cr->cr_flags & CISS_REQ_MAPPED) == 0)
2822 	return;
2823 
2824     bus_dmamap_sync(sc->ciss_command_dmat, sc->ciss_command_map,
2825 		    BUS_DMASYNC_POSTWRITE);
2826 
2827     if (cr->cr_data == NULL)
2828 	goto out;
2829 
2830     if (cr->cr_flags & CISS_REQ_DATAIN)
2831 	bus_dmamap_sync(sc->ciss_buffer_dmat, cr->cr_datamap, BUS_DMASYNC_POSTREAD);
2832     if (cr->cr_flags & CISS_REQ_DATAOUT)
2833 	bus_dmamap_sync(sc->ciss_buffer_dmat, cr->cr_datamap, BUS_DMASYNC_POSTWRITE);
2834 
2835     bus_dmamap_unload(sc->ciss_buffer_dmat, cr->cr_datamap);
2836 out:
2837     cr->cr_flags &= ~CISS_REQ_MAPPED;
2838 }
2839 
2840 /************************************************************************
2841  * Attach the driver to CAM.
2842  *
2843  * We put all the logical drives on a single SCSI bus.
2844  */
2845 static int
2846 ciss_cam_init(struct ciss_softc *sc)
2847 {
2848     int			i, maxbus;
2849 
2850     debug_called(1);
2851 
2852     /*
2853      * Allocate a devq.  We can reuse this for the masked physical
2854      * devices if we decide to export these as well.
2855      */
2856     if ((sc->ciss_cam_devq = cam_simq_alloc(sc->ciss_max_requests - 2)) == NULL) {
2857 	ciss_printf(sc, "can't allocate CAM SIM queue\n");
2858 	return(ENOMEM);
2859     }
2860 
2861     /*
2862      * Create a SIM.
2863      *
2864      * This naturally wastes a bit of memory.  The alternative is to allocate
2865      * and register each bus as it is found, and then track them on a linked
2866      * list.  Unfortunately, the driver has a few places where it needs to
2867      * look up the SIM based solely on bus number, and it's unclear whether
2868      * a list traversal would work for these situations.
2869      */
2870     maxbus = max(sc->ciss_max_logical_bus, sc->ciss_max_physical_bus +
2871 		 CISS_PHYSICAL_BASE);
2872     sc->ciss_cam_sim = malloc(maxbus * sizeof(struct cam_sim*),
2873 			      CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
2874     if (sc->ciss_cam_sim == NULL) {
2875 	ciss_printf(sc, "can't allocate memory for controller SIM\n");
2876 	return(ENOMEM);
2877     }
2878 
2879     for (i = 0; i < sc->ciss_max_logical_bus; i++) {
2880 	if ((sc->ciss_cam_sim[i] = cam_sim_alloc(ciss_cam_action, ciss_cam_poll,
2881 						 "ciss", sc,
2882 						 device_get_unit(sc->ciss_dev),
2883 						 &sc->ciss_mtx,
2884 						 2,
2885 						 sc->ciss_max_requests - 2,
2886 						 sc->ciss_cam_devq)) == NULL) {
2887 	    ciss_printf(sc, "can't allocate CAM SIM for controller %d\n", i);
2888 	    return(ENOMEM);
2889 	}
2890 
2891 	/*
2892 	 * Register bus with this SIM.
2893 	 */
2894 	mtx_lock(&sc->ciss_mtx);
2895 	if (i == 0 || sc->ciss_controllers[i].physical.bus != 0) {
2896 	    if (xpt_bus_register(sc->ciss_cam_sim[i], sc->ciss_dev, i) != 0) {
2897 		ciss_printf(sc, "can't register SCSI bus %d\n", i);
2898 		mtx_unlock(&sc->ciss_mtx);
2899 		return (ENXIO);
2900 	    }
2901 	}
2902 	mtx_unlock(&sc->ciss_mtx);
2903     }
2904 
2905     for (i = CISS_PHYSICAL_BASE; i < sc->ciss_max_physical_bus +
2906 	 CISS_PHYSICAL_BASE; i++) {
2907 	if ((sc->ciss_cam_sim[i] = cam_sim_alloc(ciss_cam_action, ciss_cam_poll,
2908 						 "ciss", sc,
2909 						 device_get_unit(sc->ciss_dev),
2910 						 &sc->ciss_mtx, 1,
2911 						 sc->ciss_max_requests - 2,
2912 						 sc->ciss_cam_devq)) == NULL) {
2913 	    ciss_printf(sc, "can't allocate CAM SIM for controller %d\n", i);
2914 	    return (ENOMEM);
2915 	}
2916 
2917 	mtx_lock(&sc->ciss_mtx);
2918 	if (xpt_bus_register(sc->ciss_cam_sim[i], sc->ciss_dev, i) != 0) {
2919 	    ciss_printf(sc, "can't register SCSI bus %d\n", i);
2920 	    mtx_unlock(&sc->ciss_mtx);
2921 	    return (ENXIO);
2922 	}
2923 	mtx_unlock(&sc->ciss_mtx);
2924     }
2925 
2926     return(0);
2927 }
2928 
2929 /************************************************************************
2930  * Initiate a rescan of the 'logical devices' SIM
2931  */
2932 static void
2933 ciss_cam_rescan_target(struct ciss_softc *sc, int bus, int target)
2934 {
2935     union ccb		*ccb;
2936 
2937     debug_called(1);
2938 
2939     if ((ccb = xpt_alloc_ccb_nowait()) == NULL) {
2940 	ciss_printf(sc, "rescan failed (can't allocate CCB)\n");
2941 	return;
2942     }
2943 
2944     if (xpt_create_path(&ccb->ccb_h.path, NULL,
2945 	    cam_sim_path(sc->ciss_cam_sim[bus]),
2946 	    target, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
2947 	ciss_printf(sc, "rescan failed (can't create path)\n");
2948 	xpt_free_ccb(ccb);
2949 	return;
2950     }
2951     xpt_rescan(ccb);
2952     /* scan is now in progress */
2953 }
2954 
2955 /************************************************************************
2956  * Handle requests coming from CAM
2957  */
2958 static void
2959 ciss_cam_action(struct cam_sim *sim, union ccb *ccb)
2960 {
2961     struct ciss_softc	*sc;
2962     struct ccb_scsiio	*csio;
2963     int			bus, target;
2964     int			physical;
2965 
2966     sc = cam_sim_softc(sim);
2967     bus = cam_sim_bus(sim);
2968     csio = (struct ccb_scsiio *)&ccb->csio;
2969     target = csio->ccb_h.target_id;
2970     physical = CISS_IS_PHYSICAL(bus);
2971 
2972     switch (ccb->ccb_h.func_code) {
2973 	/* perform SCSI I/O */
2974     case XPT_SCSI_IO:
2975 	if (!ciss_cam_action_io(sim, csio))
2976 	    return;
2977 	break;
2978 
2979 	/* perform geometry calculations */
2980     case XPT_CALC_GEOMETRY:
2981     {
2982 	struct ccb_calc_geometry	*ccg = &ccb->ccg;
2983 	struct ciss_ldrive		*ld;
2984 
2985 	debug(1, "XPT_CALC_GEOMETRY %d:%d:%d", cam_sim_bus(sim), ccb->ccb_h.target_id, ccb->ccb_h.target_lun);
2986 
2987 	ld = NULL;
2988 	if (!physical)
2989 	    ld = &sc->ciss_logical[bus][target];
2990 
2991 	/*
2992 	 * Use the cached geometry settings unless the fault tolerance
2993 	 * is invalid.
2994 	 */
2995 	if (physical || ld->cl_geometry.fault_tolerance == 0xFF) {
2996 	    u_int32_t			secs_per_cylinder;
2997 
2998 	    ccg->heads = 255;
2999 	    ccg->secs_per_track = 32;
3000 	    secs_per_cylinder = ccg->heads * ccg->secs_per_track;
3001 	    ccg->cylinders = ccg->volume_size / secs_per_cylinder;
3002 	} else {
3003 	    ccg->heads = ld->cl_geometry.heads;
3004 	    ccg->secs_per_track = ld->cl_geometry.sectors;
3005 	    ccg->cylinders = ntohs(ld->cl_geometry.cylinders);
3006 	}
3007 	ccb->ccb_h.status = CAM_REQ_CMP;
3008         break;
3009     }
3010 
3011 	/* handle path attribute inquiry */
3012     case XPT_PATH_INQ:
3013     {
3014 	struct ccb_pathinq	*cpi = &ccb->cpi;
3015 	int			sg_length;
3016 
3017 	debug(1, "XPT_PATH_INQ %d:%d:%d", cam_sim_bus(sim), ccb->ccb_h.target_id, ccb->ccb_h.target_lun);
3018 
3019 	cpi->version_num = 1;
3020 	cpi->hba_inquiry = PI_TAG_ABLE;	/* XXX is this correct? */
3021 	cpi->target_sprt = 0;
3022 	cpi->hba_misc = 0;
3023 	cpi->max_target = sc->ciss_cfg->max_logical_supported;
3024 	cpi->max_lun = 0;		/* 'logical drive' channel only */
3025 	cpi->initiator_id = sc->ciss_cfg->max_logical_supported;
3026 	strlcpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
3027 	strlcpy(cpi->hba_vid, "CISS", HBA_IDLEN);
3028 	strlcpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
3029 	cpi->unit_number = cam_sim_unit(sim);
3030 	cpi->bus_id = cam_sim_bus(sim);
3031 	cpi->base_transfer_speed = 132 * 1024;	/* XXX what to set this to? */
3032 	cpi->transport = XPORT_SPI;
3033 	cpi->transport_version = 2;
3034 	cpi->protocol = PROTO_SCSI;
3035 	cpi->protocol_version = SCSI_REV_2;
3036 	if (sc->ciss_cfg->max_sg_length == 0) {
3037 		sg_length = 17;
3038 	} else {
3039 	/* XXX Fix for ZMR cards that advertise max_sg_length == 32
3040 	 * Confusing bit here. max_sg_length is usually a power of 2. We always
3041 	 * need to subtract 1 to account for partial pages. Then we need to
3042 	 * align on a valid PAGE_SIZE so we round down to the nearest power of 2.
3043 	 * Add 1 so we can then subtract it out in the assignment to maxio.
3044 	 * The reason for all these shenanigans is to create a maxio value that
3045 	 * creates IO operations to volumes that yield consistent operations
3046 	 * with good performance.
3047 	 */
3048 		sg_length = sc->ciss_cfg->max_sg_length - 1;
3049 		sg_length = (1 << (fls(sg_length) - 1)) + 1;
3050 	}
3051 	cpi->maxio = (min(CISS_MAX_SG_ELEMENTS, sg_length) - 1) * PAGE_SIZE;
3052 	ccb->ccb_h.status = CAM_REQ_CMP;
3053 	break;
3054     }
3055 
3056     case XPT_GET_TRAN_SETTINGS:
3057     {
3058 	struct ccb_trans_settings	*cts = &ccb->cts;
3059 	struct ccb_trans_settings_spi *spi = &cts->xport_specific.spi;
3060 	struct ccb_trans_settings_scsi *scsi = &cts->proto_specific.scsi;
3061 
3062 	debug(1, "XPT_GET_TRAN_SETTINGS %d:%d", cam_sim_bus(sim),
3063 	    ctl->ccb_h.target_id);
3064 	/* disconnect always OK */
3065 	cts->protocol = PROTO_SCSI;
3066 	cts->protocol_version = SCSI_REV_2;
3067 	cts->transport = XPORT_SPI;
3068 	cts->transport_version = 2;
3069 
3070 	spi->valid = CTS_SPI_VALID_DISC;
3071 	spi->flags = CTS_SPI_FLAGS_DISC_ENB;
3072 
3073 	scsi->valid = CTS_SCSI_VALID_TQ;
3074 	scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
3075 
3076 	cts->ccb_h.status = CAM_REQ_CMP;
3077 	break;
3078     }
3079 
3080     default:		/* we can't do this */
3081 	debug(1, "unspported func_code = 0x%x", ccb->ccb_h.func_code);
3082 	ccb->ccb_h.status = CAM_REQ_INVALID;
3083 	break;
3084     }
3085 
3086     xpt_done(ccb);
3087 }
3088 
3089 /************************************************************************
3090  * Handle a CAM SCSI I/O request.
3091  */
3092 static int
3093 ciss_cam_action_io(struct cam_sim *sim, struct ccb_scsiio *csio)
3094 {
3095     struct ciss_softc	*sc;
3096     int			bus, target;
3097     struct ciss_request	*cr;
3098     struct ciss_command	*cc;
3099     int			error;
3100 
3101     sc = cam_sim_softc(sim);
3102     bus = cam_sim_bus(sim);
3103     target = csio->ccb_h.target_id;
3104 
3105     debug(2, "XPT_SCSI_IO %d:%d:%d", bus, target, csio->ccb_h.target_lun);
3106 
3107     /* check that the CDB pointer is not to a physical address */
3108     if ((csio->ccb_h.flags & CAM_CDB_POINTER) && (csio->ccb_h.flags & CAM_CDB_PHYS)) {
3109 	debug(3, "  CDB pointer is to physical address");
3110 	csio->ccb_h.status = CAM_REQ_CMP_ERR;
3111     }
3112 
3113     /* abandon aborted ccbs or those that have failed validation */
3114     if ((csio->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_INPROG) {
3115 	debug(3, "abandoning CCB due to abort/validation failure");
3116 	return(EINVAL);
3117     }
3118 
3119     /* handle emulation of some SCSI commands ourself */
3120     if (ciss_cam_emulate(sc, csio))
3121 	return(0);
3122 
3123     /*
3124      * Get a request to manage this command.  If we can't, return the
3125      * ccb, freeze the queue and flag so that we unfreeze it when a
3126      * request completes.
3127      */
3128     if ((error = ciss_get_request(sc, &cr)) != 0) {
3129 	xpt_freeze_simq(sim, 1);
3130 	sc->ciss_flags |= CISS_FLAG_BUSY;
3131 	csio->ccb_h.status |= CAM_REQUEUE_REQ;
3132 	return(error);
3133     }
3134 
3135     /*
3136      * Build the command.
3137      */
3138     cc = cr->cr_cc;
3139     cr->cr_data = csio;
3140     cr->cr_length = csio->dxfer_len;
3141     cr->cr_complete = ciss_cam_complete;
3142     cr->cr_private = csio;
3143 
3144     /*
3145      * Target the right logical volume.
3146      */
3147     if (CISS_IS_PHYSICAL(bus))
3148 	cc->header.address =
3149 	    sc->ciss_physical[CISS_CAM_TO_PBUS(bus)][target].cp_address;
3150     else
3151 	cc->header.address =
3152 	    sc->ciss_logical[bus][target].cl_address;
3153     cc->cdb.cdb_length = csio->cdb_len;
3154     cc->cdb.type = CISS_CDB_TYPE_COMMAND;
3155     cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;	/* XXX ordered tags? */
3156     if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT) {
3157 	cr->cr_flags = CISS_REQ_DATAOUT | CISS_REQ_CCB;
3158 	cc->cdb.direction = CISS_CDB_DIRECTION_WRITE;
3159     } else if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
3160 	cr->cr_flags = CISS_REQ_DATAIN | CISS_REQ_CCB;
3161 	cc->cdb.direction = CISS_CDB_DIRECTION_READ;
3162     } else {
3163 	cr->cr_data = NULL;
3164 	cr->cr_flags = 0;
3165 	cc->cdb.direction = CISS_CDB_DIRECTION_NONE;
3166     }
3167     cc->cdb.timeout = (csio->ccb_h.timeout / 1000) + 1;
3168     if (csio->ccb_h.flags & CAM_CDB_POINTER) {
3169 	bcopy(csio->cdb_io.cdb_ptr, &cc->cdb.cdb[0], csio->cdb_len);
3170     } else {
3171 	bcopy(csio->cdb_io.cdb_bytes, &cc->cdb.cdb[0], csio->cdb_len);
3172     }
3173 
3174     /*
3175      * Submit the request to the adapter.
3176      *
3177      * Note that this may fail if we're unable to map the request (and
3178      * if we ever learn a transport layer other than simple, may fail
3179      * if the adapter rejects the command).
3180      */
3181     if ((error = ciss_start(cr)) != 0) {
3182 	xpt_freeze_simq(sim, 1);
3183 	csio->ccb_h.status |= CAM_RELEASE_SIMQ;
3184 	if (error == EINPROGRESS) {
3185 	    error = 0;
3186 	} else {
3187 	    csio->ccb_h.status |= CAM_REQUEUE_REQ;
3188 	    ciss_release_request(cr);
3189 	}
3190 	return(error);
3191     }
3192 
3193     return(0);
3194 }
3195 
3196 /************************************************************************
3197  * Emulate SCSI commands the adapter doesn't handle as we might like.
3198  */
3199 static int
3200 ciss_cam_emulate(struct ciss_softc *sc, struct ccb_scsiio *csio)
3201 {
3202     int		bus, target;
3203     u_int8_t	opcode;
3204 
3205     target = csio->ccb_h.target_id;
3206     bus = cam_sim_bus(xpt_path_sim(csio->ccb_h.path));
3207     opcode = (csio->ccb_h.flags & CAM_CDB_POINTER) ?
3208 	*(u_int8_t *)csio->cdb_io.cdb_ptr : csio->cdb_io.cdb_bytes[0];
3209 
3210     if (CISS_IS_PHYSICAL(bus)) {
3211 	if (sc->ciss_physical[CISS_CAM_TO_PBUS(bus)][target].cp_online != 1) {
3212 	    csio->ccb_h.status |= CAM_SEL_TIMEOUT;
3213 	    xpt_done((union ccb *)csio);
3214 	    return(1);
3215 	} else
3216 	    return(0);
3217     }
3218 
3219     /*
3220      * Handle requests for volumes that don't exist or are not online.
3221      * A selection timeout is slightly better than an illegal request.
3222      * Other errors might be better.
3223      */
3224     if (sc->ciss_logical[bus][target].cl_status != CISS_LD_ONLINE) {
3225 	csio->ccb_h.status |= CAM_SEL_TIMEOUT;
3226 	xpt_done((union ccb *)csio);
3227 	return(1);
3228     }
3229 
3230     /* if we have to fake Synchronise Cache */
3231     if (sc->ciss_flags & CISS_FLAG_FAKE_SYNCH) {
3232 	/*
3233 	 * If this is a Synchronise Cache command, typically issued when
3234 	 * a device is closed, flush the adapter and complete now.
3235 	 */
3236 	if (((csio->ccb_h.flags & CAM_CDB_POINTER) ?
3237 	     *(u_int8_t *)csio->cdb_io.cdb_ptr : csio->cdb_io.cdb_bytes[0]) == SYNCHRONIZE_CACHE) {
3238 	    ciss_flush_adapter(sc);
3239 	    csio->ccb_h.status |= CAM_REQ_CMP;
3240 	    xpt_done((union ccb *)csio);
3241 	    return(1);
3242 	}
3243     }
3244 
3245     /*
3246      * A CISS target can only ever have one lun per target. REPORT_LUNS requires
3247      * at least one LUN field to be pre created for us, so snag it and fill in
3248      * the least significant byte indicating 1 LUN here.  Emulate the command
3249      * return to shut up warning on console of a CDB error.  swb
3250      */
3251     if (opcode == REPORT_LUNS && csio->dxfer_len > 0) {
3252        csio->data_ptr[3] = 8;
3253        csio->ccb_h.status |= CAM_REQ_CMP;
3254        xpt_done((union ccb *)csio);
3255        return(1);
3256     }
3257 
3258     return(0);
3259 }
3260 
3261 /************************************************************************
3262  * Check for possibly-completed commands.
3263  */
3264 static void
3265 ciss_cam_poll(struct cam_sim *sim)
3266 {
3267     cr_qhead_t qh;
3268     struct ciss_softc	*sc = cam_sim_softc(sim);
3269 
3270     debug_called(2);
3271 
3272     STAILQ_INIT(&qh);
3273     if (sc->ciss_perf)
3274 	ciss_perf_done(sc, &qh);
3275     else
3276 	ciss_done(sc, &qh);
3277     ciss_complete(sc, &qh);
3278 }
3279 
3280 /************************************************************************
3281  * Handle completion of a command - pass results back through the CCB
3282  */
3283 static void
3284 ciss_cam_complete(struct ciss_request *cr)
3285 {
3286     struct ciss_softc		*sc;
3287     struct ciss_command		*cc;
3288     struct ciss_error_info	*ce;
3289     struct ccb_scsiio		*csio;
3290     int				scsi_status;
3291     int				command_status;
3292 
3293     debug_called(2);
3294 
3295     sc = cr->cr_sc;
3296     cc = cr->cr_cc;
3297     ce = (struct ciss_error_info *)&(cc->sg[0]);
3298     csio = (struct ccb_scsiio *)cr->cr_private;
3299 
3300     /*
3301      * Extract status values from request.
3302      */
3303     ciss_report_request(cr, &command_status, &scsi_status);
3304     switch(command_status) {
3305     case CISS_CMD_STATUS_DATA_UNDERRUN:
3306 	csio->resid = ce->residual_count;
3307 	/* FALLTHROUGH */
3308     case CISS_CMD_STATUS_SUCCESS:
3309 	csio->scsi_status = scsi_status;
3310 	debug(2, "SCSI_STATUS_OK");
3311 	csio->ccb_h.status |= CAM_REQ_CMP;
3312 	break;
3313     case CISS_CMD_STATUS_TARGET_STATUS:
3314 	csio->scsi_status = scsi_status;
3315 	bzero(&csio->sense_data, SSD_FULL_SIZE);
3316 	bcopy(&ce->sense_info[0], &csio->sense_data, ce->sense_length);
3317 	if (csio->sense_len > ce->sense_length)
3318 		csio->sense_resid = csio->sense_len - ce->sense_length;
3319 	else
3320 		csio->sense_resid = 0;
3321 	csio->resid = ce->residual_count;
3322 	csio->ccb_h.status |= CAM_SCSI_STATUS_ERROR | CAM_AUTOSNS_VALID;
3323 	break;
3324     case CISS_CMD_STATUS_DATA_OVERRUN:
3325 	csio->ccb_h.status |= CAM_DATA_RUN_ERR;
3326 	break;
3327     default:
3328 	csio->ccb_h.status |= CAM_REQ_CMP_ERR;
3329 	break;
3330     }
3331 
3332     /* handle post-command fixup */
3333     ciss_cam_complete_fixup(sc, csio);
3334 
3335     ciss_release_request(cr);
3336     if (sc->ciss_flags & CISS_FLAG_BUSY) {
3337 	sc->ciss_flags &= ~CISS_FLAG_BUSY;
3338 	if (csio->ccb_h.status & CAM_RELEASE_SIMQ)
3339 	    xpt_release_simq(xpt_path_sim(csio->ccb_h.path), 0);
3340 	else
3341 	    csio->ccb_h.status |= CAM_RELEASE_SIMQ;
3342     }
3343     xpt_done((union ccb *)csio);
3344 }
3345 
3346 /********************************************************************************
3347  * Fix up the result of some commands here.
3348  */
3349 static void
3350 ciss_cam_complete_fixup(struct ciss_softc *sc, struct ccb_scsiio *csio)
3351 {
3352     struct scsi_inquiry_data	*inq;
3353     struct ciss_ldrive		*cl;
3354     uint8_t			*cdb;
3355     int				bus, target;
3356 
3357     cdb = (csio->ccb_h.flags & CAM_CDB_POINTER) ?
3358 	 (uint8_t *)csio->cdb_io.cdb_ptr : csio->cdb_io.cdb_bytes;
3359     if (cdb[0] == INQUIRY &&
3360 	(cdb[1] & SI_EVPD) == 0 &&
3361 	(csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN &&
3362 	csio->dxfer_len >= SHORT_INQUIRY_LENGTH) {
3363 	inq = (struct scsi_inquiry_data *)csio->data_ptr;
3364 	target = csio->ccb_h.target_id;
3365 	bus = cam_sim_bus(xpt_path_sim(csio->ccb_h.path));
3366 
3367 	/*
3368 	 * If the controller is in JBOD mode, there are no logical volumes.
3369 	 * Let the disks be probed and dealt with via CAM.  Else, mask off
3370 	 * the physical disks and setup the parts of the inq structure for
3371 	 * the logical volume.  swb
3372 	 */
3373 	if( !(sc->ciss_id->PowerUPNvramFlags & PWR_UP_FLAG_JBOD_ENABLED)){
3374 		if (CISS_IS_PHYSICAL(bus)) {
3375 	    		if (SID_TYPE(inq) == T_DIRECT)
3376 				inq->device = (inq->device & 0xe0) | T_NODEVICE;
3377 	    		return;
3378 		}
3379 		cl = &sc->ciss_logical[bus][target];
3380 
3381 		padstr(inq->vendor, "HP",
3382 	       		SID_VENDOR_SIZE);
3383 		padstr(inq->product,
3384 	       		ciss_name_ldrive_org(cl->cl_ldrive->fault_tolerance),
3385 	       		SID_PRODUCT_SIZE);
3386 		padstr(inq->revision,
3387 	       		ciss_name_ldrive_status(cl->cl_lstatus->status),
3388 	       		SID_REVISION_SIZE);
3389 	}
3390     }
3391 }
3392 
3393 /********************************************************************************
3394  * Name the device at (target)
3395  *
3396  * XXX is this strictly correct?
3397  */
3398 static int
3399 ciss_name_device(struct ciss_softc *sc, int bus, int target)
3400 {
3401     struct cam_periph	*periph;
3402     struct cam_path	*path;
3403     int			status;
3404 
3405     if (CISS_IS_PHYSICAL(bus))
3406 	return (0);
3407 
3408     status = xpt_create_path(&path, NULL, cam_sim_path(sc->ciss_cam_sim[bus]),
3409 			     target, 0);
3410 
3411     if (status == CAM_REQ_CMP) {
3412 	xpt_path_lock(path);
3413 	periph = cam_periph_find(path, NULL);
3414 	xpt_path_unlock(path);
3415 	xpt_free_path(path);
3416 	if (periph != NULL) {
3417 		sprintf(sc->ciss_logical[bus][target].cl_name, "%s%d",
3418 			periph->periph_name, periph->unit_number);
3419 		return(0);
3420 	}
3421     }
3422     sc->ciss_logical[bus][target].cl_name[0] = 0;
3423     return(ENOENT);
3424 }
3425 
3426 /************************************************************************
3427  * Periodic status monitoring.
3428  */
3429 static void
3430 ciss_periodic(void *arg)
3431 {
3432     struct ciss_softc	*sc;
3433     struct ciss_request	*cr = NULL;
3434     struct ciss_command	*cc = NULL;
3435     int			error = 0;
3436 
3437     debug_called(1);
3438 
3439     sc = (struct ciss_softc *)arg;
3440 
3441     /*
3442      * Check the adapter heartbeat.
3443      */
3444     if (sc->ciss_cfg->heartbeat == sc->ciss_heartbeat) {
3445 	sc->ciss_heart_attack++;
3446 	debug(0, "adapter heart attack in progress 0x%x/%d",
3447 	      sc->ciss_heartbeat, sc->ciss_heart_attack);
3448 	if (sc->ciss_heart_attack == 3) {
3449 	    ciss_printf(sc, "ADAPTER HEARTBEAT FAILED\n");
3450 	    ciss_disable_adapter(sc);
3451 	    return;
3452 	}
3453     } else {
3454 	sc->ciss_heartbeat = sc->ciss_cfg->heartbeat;
3455 	sc->ciss_heart_attack = 0;
3456 	debug(3, "new heartbeat 0x%x", sc->ciss_heartbeat);
3457     }
3458 
3459     /*
3460      * Send the NOP message and wait for a response.
3461      */
3462     if (ciss_nop_message_heartbeat != 0 && (error = ciss_get_request(sc, &cr)) == 0) {
3463 	cc = cr->cr_cc;
3464 	cr->cr_complete = ciss_nop_complete;
3465 	cc->cdb.cdb_length = 1;
3466 	cc->cdb.type = CISS_CDB_TYPE_MESSAGE;
3467 	cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;
3468 	cc->cdb.direction = CISS_CDB_DIRECTION_WRITE;
3469 	cc->cdb.timeout = 0;
3470 	cc->cdb.cdb[0] = CISS_OPCODE_MESSAGE_NOP;
3471 
3472 	if ((error = ciss_start(cr)) != 0) {
3473 	    ciss_printf(sc, "SENDING NOP MESSAGE FAILED\n");
3474 	}
3475     }
3476 
3477     /*
3478      * If the notify event request has died for some reason, or has
3479      * not started yet, restart it.
3480      */
3481     if (!(sc->ciss_flags & CISS_FLAG_NOTIFY_OK)) {
3482 	debug(0, "(re)starting Event Notify chain");
3483 	ciss_notify_event(sc);
3484     }
3485 
3486     /*
3487      * Reschedule.
3488      */
3489     callout_reset(&sc->ciss_periodic, CISS_HEARTBEAT_RATE * hz, ciss_periodic, sc);
3490 }
3491 
3492 static void
3493 ciss_nop_complete(struct ciss_request *cr)
3494 {
3495     struct ciss_softc		*sc;
3496     static int			first_time = 1;
3497 
3498     sc = cr->cr_sc;
3499     if (ciss_report_request(cr, NULL, NULL) != 0) {
3500 	if (first_time == 1) {
3501 	    first_time = 0;
3502 	    ciss_printf(sc, "SENDING NOP MESSAGE FAILED (not logging anymore)\n");
3503 	}
3504     }
3505 
3506     ciss_release_request(cr);
3507 }
3508 
3509 /************************************************************************
3510  * Disable the adapter.
3511  *
3512  * The all requests in completed queue is failed with hardware error.
3513  * This will cause failover in a multipath configuration.
3514  */
3515 static void
3516 ciss_disable_adapter(struct ciss_softc *sc)
3517 {
3518     cr_qhead_t			qh;
3519     struct ciss_request		*cr;
3520     struct ciss_command		*cc;
3521     struct ciss_error_info	*ce;
3522     int				i;
3523 
3524     CISS_TL_SIMPLE_DISABLE_INTERRUPTS(sc);
3525     pci_disable_busmaster(sc->ciss_dev);
3526     sc->ciss_flags &= ~CISS_FLAG_RUNNING;
3527 
3528     STAILQ_INIT(&qh);
3529     for (i = 1; i < sc->ciss_max_requests; i++) {
3530 	cr = &sc->ciss_request[i];
3531 	if ((cr->cr_flags & CISS_REQ_BUSY) == 0)
3532 	    continue;
3533 
3534 	cc = cr->cr_cc;
3535 	ce = (struct ciss_error_info *)&(cc->sg[0]);
3536 	ce->command_status = CISS_CMD_STATUS_HARDWARE_ERROR;
3537 	ciss_enqueue_complete(cr, &qh);
3538     }
3539 
3540     for (;;) {
3541 	if ((cr = ciss_dequeue_complete(sc, &qh)) == NULL)
3542 	    break;
3543 
3544 	/*
3545 	 * If the request has a callback, invoke it.
3546 	 */
3547 	if (cr->cr_complete != NULL) {
3548 	    cr->cr_complete(cr);
3549 	    continue;
3550 	}
3551 
3552 	/*
3553 	 * If someone is sleeping on this request, wake them up.
3554 	 */
3555 	if (cr->cr_flags & CISS_REQ_SLEEP) {
3556 	    cr->cr_flags &= ~CISS_REQ_SLEEP;
3557 	    wakeup(cr);
3558 	    continue;
3559 	}
3560     }
3561 }
3562 
3563 /************************************************************************
3564  * Request a notification response from the adapter.
3565  *
3566  * If (cr) is NULL, this is the first request of the adapter, so
3567  * reset the adapter's message pointer and start with the oldest
3568  * message available.
3569  */
3570 static void
3571 ciss_notify_event(struct ciss_softc *sc)
3572 {
3573     struct ciss_request		*cr;
3574     struct ciss_command		*cc;
3575     struct ciss_notify_cdb	*cnc;
3576     int				error;
3577 
3578     debug_called(1);
3579 
3580     cr = sc->ciss_periodic_notify;
3581 
3582     /* get a request if we don't already have one */
3583     if (cr == NULL) {
3584 	if ((error = ciss_get_request(sc, &cr)) != 0) {
3585 	    debug(0, "can't get notify event request");
3586 	    goto out;
3587 	}
3588 	sc->ciss_periodic_notify = cr;
3589 	cr->cr_complete = ciss_notify_complete;
3590 	debug(1, "acquired request %d", cr->cr_tag);
3591     }
3592 
3593     /*
3594      * Get a databuffer if we don't already have one, note that the
3595      * adapter command wants a larger buffer than the actual
3596      * structure.
3597      */
3598     if (cr->cr_data == NULL) {
3599 	if ((cr->cr_data = malloc(CISS_NOTIFY_DATA_SIZE, CISS_MALLOC_CLASS, M_NOWAIT)) == NULL) {
3600 	    debug(0, "can't get notify event request buffer");
3601 	    error = ENOMEM;
3602 	    goto out;
3603 	}
3604 	cr->cr_length = CISS_NOTIFY_DATA_SIZE;
3605     }
3606 
3607     /* re-setup the request's command (since we never release it) XXX overkill*/
3608     ciss_preen_command(cr);
3609 
3610     /* (re)build the notify event command */
3611     cc = cr->cr_cc;
3612     cc->header.address.physical.mode = CISS_HDR_ADDRESS_MODE_PERIPHERAL;
3613     cc->header.address.physical.bus = 0;
3614     cc->header.address.physical.target = 0;
3615 
3616     cc->cdb.cdb_length = sizeof(*cnc);
3617     cc->cdb.type = CISS_CDB_TYPE_COMMAND;
3618     cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;
3619     cc->cdb.direction = CISS_CDB_DIRECTION_READ;
3620     cc->cdb.timeout = 0;	/* no timeout, we hope */
3621 
3622     cnc = (struct ciss_notify_cdb *)&(cc->cdb.cdb[0]);
3623     bzero(cr->cr_data, CISS_NOTIFY_DATA_SIZE);
3624     cnc->opcode = CISS_OPCODE_READ;
3625     cnc->command = CISS_COMMAND_NOTIFY_ON_EVENT;
3626     cnc->timeout = 0;		/* no timeout, we hope */
3627     cnc->synchronous = 0;
3628     cnc->ordered = 0;
3629     cnc->seek_to_oldest = 0;
3630     if ((sc->ciss_flags & CISS_FLAG_RUNNING) == 0)
3631 	cnc->new_only = 1;
3632     else
3633 	cnc->new_only = 0;
3634     cnc->length = htonl(CISS_NOTIFY_DATA_SIZE);
3635 
3636     /* submit the request */
3637     error = ciss_start(cr);
3638 
3639  out:
3640     if (error) {
3641 	if (cr != NULL) {
3642 	    if (cr->cr_data != NULL)
3643 		free(cr->cr_data, CISS_MALLOC_CLASS);
3644 	    ciss_release_request(cr);
3645 	}
3646 	sc->ciss_periodic_notify = NULL;
3647 	debug(0, "can't submit notify event request");
3648 	sc->ciss_flags &= ~CISS_FLAG_NOTIFY_OK;
3649     } else {
3650 	debug(1, "notify event submitted");
3651 	sc->ciss_flags |= CISS_FLAG_NOTIFY_OK;
3652     }
3653 }
3654 
3655 static void
3656 ciss_notify_complete(struct ciss_request *cr)
3657 {
3658     struct ciss_notify	*cn;
3659     struct ciss_softc	*sc;
3660     int			scsi_status;
3661     int			command_status;
3662     debug_called(1);
3663 
3664     cn = (struct ciss_notify *)cr->cr_data;
3665     sc = cr->cr_sc;
3666 
3667     /*
3668      * Report request results, decode status.
3669      */
3670     ciss_report_request(cr, &command_status, &scsi_status);
3671 
3672     /*
3673      * Abort the chain on a fatal error.
3674      *
3675      * XXX which of these are actually errors?
3676      */
3677     if ((command_status != CISS_CMD_STATUS_SUCCESS) &&
3678 	(command_status != CISS_CMD_STATUS_TARGET_STATUS) &&
3679 	(command_status != CISS_CMD_STATUS_TIMEOUT)) {	/* XXX timeout? */
3680 	ciss_printf(sc, "fatal error in Notify Event request (%s)\n",
3681 		    ciss_name_command_status(command_status));
3682 	ciss_release_request(cr);
3683 	sc->ciss_flags &= ~CISS_FLAG_NOTIFY_OK;
3684 	return;
3685     }
3686 
3687     /*
3688      * If the adapter gave us a text message, print it.
3689      */
3690     if (cn->message[0] != 0)
3691 	ciss_printf(sc, "*** %.80s\n", cn->message);
3692 
3693     debug(0, "notify event class %d subclass %d detail %d",
3694 		cn->class, cn->subclass, cn->detail);
3695 
3696     /*
3697      * If the response indicates that the notifier has been aborted,
3698      * release the notifier command.
3699      */
3700     if ((cn->class == CISS_NOTIFY_NOTIFIER) &&
3701 	(cn->subclass == CISS_NOTIFY_NOTIFIER_STATUS) &&
3702 	(cn->detail == 1)) {
3703 	debug(0, "notifier exiting");
3704 	sc->ciss_flags &= ~CISS_FLAG_NOTIFY_OK;
3705 	ciss_release_request(cr);
3706 	sc->ciss_periodic_notify = NULL;
3707 	wakeup(&sc->ciss_periodic_notify);
3708     } else {
3709 	/* Handle notify events in a kernel thread */
3710 	ciss_enqueue_notify(cr);
3711 	sc->ciss_periodic_notify = NULL;
3712 	wakeup(&sc->ciss_periodic_notify);
3713 	wakeup(&sc->ciss_notify);
3714     }
3715     /*
3716      * Send a new notify event command, if we're not aborting.
3717      */
3718     if (!(sc->ciss_flags & CISS_FLAG_ABORTING)) {
3719 	ciss_notify_event(sc);
3720     }
3721 }
3722 
3723 /************************************************************************
3724  * Abort the Notify Event chain.
3725  *
3726  * Note that we can't just abort the command in progress; we have to
3727  * explicitly issue an Abort Notify Event command in order for the
3728  * adapter to clean up correctly.
3729  *
3730  * If we are called with CISS_FLAG_ABORTING set in the adapter softc,
3731  * the chain will not restart itself.
3732  */
3733 static int
3734 ciss_notify_abort(struct ciss_softc *sc)
3735 {
3736     struct ciss_request		*cr;
3737     struct ciss_command		*cc;
3738     struct ciss_notify_cdb	*cnc;
3739     int				error, command_status, scsi_status;
3740 
3741     debug_called(1);
3742 
3743     cr = NULL;
3744     error = 0;
3745 
3746     /* verify that there's an outstanding command */
3747     if (!(sc->ciss_flags & CISS_FLAG_NOTIFY_OK))
3748 	goto out;
3749 
3750     /* get a command to issue the abort with */
3751     if ((error = ciss_get_request(sc, &cr)))
3752 	goto out;
3753 
3754     /* get a buffer for the result */
3755     if ((cr->cr_data = malloc(CISS_NOTIFY_DATA_SIZE, CISS_MALLOC_CLASS, M_NOWAIT)) == NULL) {
3756 	debug(0, "can't get notify event request buffer");
3757 	error = ENOMEM;
3758 	goto out;
3759     }
3760     cr->cr_length = CISS_NOTIFY_DATA_SIZE;
3761 
3762     /* build the CDB */
3763     cc = cr->cr_cc;
3764     cc->header.address.physical.mode = CISS_HDR_ADDRESS_MODE_PERIPHERAL;
3765     cc->header.address.physical.bus = 0;
3766     cc->header.address.physical.target = 0;
3767     cc->cdb.cdb_length = sizeof(*cnc);
3768     cc->cdb.type = CISS_CDB_TYPE_COMMAND;
3769     cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;
3770     cc->cdb.direction = CISS_CDB_DIRECTION_READ;
3771     cc->cdb.timeout = 0;	/* no timeout, we hope */
3772 
3773     cnc = (struct ciss_notify_cdb *)&(cc->cdb.cdb[0]);
3774     bzero(cnc, sizeof(*cnc));
3775     cnc->opcode = CISS_OPCODE_WRITE;
3776     cnc->command = CISS_COMMAND_ABORT_NOTIFY;
3777     cnc->length = htonl(CISS_NOTIFY_DATA_SIZE);
3778 #if 0
3779     ciss_print_request(cr);
3780 #endif
3781 
3782     /*
3783      * Submit the request and wait for it to complete.
3784      */
3785     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
3786 	ciss_printf(sc, "Abort Notify Event command failed (%d)\n", error);
3787 	goto out;
3788     }
3789 
3790     /*
3791      * Check response.
3792      */
3793     ciss_report_request(cr, &command_status, &scsi_status);
3794     switch(command_status) {
3795     case CISS_CMD_STATUS_SUCCESS:
3796 	break;
3797     case CISS_CMD_STATUS_INVALID_COMMAND:
3798 	/*
3799 	 * Some older adapters don't support the CISS version of this
3800 	 * command.  Fall back to using the BMIC version.
3801 	 */
3802 	error = ciss_notify_abort_bmic(sc);
3803 	if (error != 0)
3804 	    goto out;
3805 	break;
3806 
3807     case CISS_CMD_STATUS_TARGET_STATUS:
3808 	/*
3809 	 * This can happen if the adapter thinks there wasn't an outstanding
3810 	 * Notify Event command but we did.  We clean up here.
3811 	 */
3812 	if (scsi_status == CISS_SCSI_STATUS_CHECK_CONDITION) {
3813 	    if (sc->ciss_periodic_notify != NULL)
3814 		ciss_release_request(sc->ciss_periodic_notify);
3815 	    error = 0;
3816 	    goto out;
3817 	}
3818 	/* FALLTHROUGH */
3819 
3820     default:
3821 	ciss_printf(sc, "Abort Notify Event command failed (%s)\n",
3822 		    ciss_name_command_status(command_status));
3823 	error = EIO;
3824 	goto out;
3825     }
3826 
3827     /*
3828      * Sleep waiting for the notifier command to complete.  Note
3829      * that if it doesn't, we may end up in a bad situation, since
3830      * the adapter may deliver it later.  Also note that the adapter
3831      * requires the Notify Event command to be cancelled in order to
3832      * maintain internal bookkeeping.
3833      */
3834     while (sc->ciss_periodic_notify != NULL) {
3835 	error = msleep(&sc->ciss_periodic_notify, &sc->ciss_mtx, PRIBIO, "cissNEA", hz * 5);
3836 	if (error == EWOULDBLOCK) {
3837 	    ciss_printf(sc, "Notify Event command failed to abort, adapter may wedge.\n");
3838 	    break;
3839 	}
3840     }
3841 
3842  out:
3843     /* release the cancel request */
3844     if (cr != NULL) {
3845 	if (cr->cr_data != NULL)
3846 	    free(cr->cr_data, CISS_MALLOC_CLASS);
3847 	ciss_release_request(cr);
3848     }
3849     if (error == 0)
3850 	sc->ciss_flags &= ~CISS_FLAG_NOTIFY_OK;
3851     return(error);
3852 }
3853 
3854 /************************************************************************
3855  * Abort the Notify Event chain using a BMIC command.
3856  */
3857 static int
3858 ciss_notify_abort_bmic(struct ciss_softc *sc)
3859 {
3860     struct ciss_request			*cr;
3861     int					error, command_status;
3862 
3863     debug_called(1);
3864 
3865     cr = NULL;
3866     error = 0;
3867 
3868     /* verify that there's an outstanding command */
3869     if (!(sc->ciss_flags & CISS_FLAG_NOTIFY_OK))
3870 	goto out;
3871 
3872     /*
3873      * Build a BMIC command to cancel the Notify on Event command.
3874      *
3875      * Note that we are sending a CISS opcode here.  Odd.
3876      */
3877     if ((error = ciss_get_bmic_request(sc, &cr, CISS_COMMAND_ABORT_NOTIFY,
3878 				       NULL, 0)) != 0)
3879 	goto out;
3880 
3881     /*
3882      * Submit the request and wait for it to complete.
3883      */
3884     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
3885 	ciss_printf(sc, "error sending BMIC Cancel Notify on Event command (%d)\n", error);
3886 	goto out;
3887     }
3888 
3889     /*
3890      * Check response.
3891      */
3892     ciss_report_request(cr, &command_status, NULL);
3893     switch(command_status) {
3894     case CISS_CMD_STATUS_SUCCESS:
3895 	break;
3896     default:
3897 	ciss_printf(sc, "error cancelling Notify on Event (%s)\n",
3898 		    ciss_name_command_status(command_status));
3899 	error = EIO;
3900 	goto out;
3901     }
3902 
3903 out:
3904     if (cr != NULL)
3905 	ciss_release_request(cr);
3906     return(error);
3907 }
3908 
3909 /************************************************************************
3910  * Handle rescanning all the logical volumes when a notify event
3911  * causes the drives to come online or offline.
3912  */
3913 static void
3914 ciss_notify_rescan_logical(struct ciss_softc *sc)
3915 {
3916     struct ciss_lun_report      *cll;
3917     struct ciss_ldrive		*ld;
3918     int                         i, j, ndrives;
3919 
3920     /*
3921      * We must rescan all logical volumes to get the right logical
3922      * drive address.
3923      */
3924     cll = ciss_report_luns(sc, CISS_OPCODE_REPORT_LOGICAL_LUNS,
3925                            sc->ciss_cfg->max_logical_supported);
3926     if (cll == NULL)
3927         return;
3928 
3929     ndrives = (ntohl(cll->list_size) / sizeof(union ciss_device_address));
3930 
3931     /*
3932      * Delete any of the drives which were destroyed by the
3933      * firmware.
3934      */
3935     for (i = 0; i < sc->ciss_max_logical_bus; i++) {
3936 	for (j = 0; j < sc->ciss_cfg->max_logical_supported; j++) {
3937 	    ld = &sc->ciss_logical[i][j];
3938 
3939 	    if (ld->cl_update == 0)
3940 		continue;
3941 
3942 	    if (ld->cl_status != CISS_LD_ONLINE) {
3943 		ciss_cam_rescan_target(sc, i, j);
3944 		ld->cl_update = 0;
3945 		if (ld->cl_ldrive)
3946 		    free(ld->cl_ldrive, CISS_MALLOC_CLASS);
3947 		if (ld->cl_lstatus)
3948 		    free(ld->cl_lstatus, CISS_MALLOC_CLASS);
3949 
3950 		ld->cl_ldrive = NULL;
3951 		ld->cl_lstatus = NULL;
3952 	    }
3953 	}
3954     }
3955 
3956     /*
3957      * Scan for new drives.
3958      */
3959     for (i = 0; i < ndrives; i++) {
3960 	int	bus, target;
3961 
3962 	bus 	= CISS_LUN_TO_BUS(cll->lun[i].logical.lun);
3963 	target	= CISS_LUN_TO_TARGET(cll->lun[i].logical.lun);
3964 	ld	= &sc->ciss_logical[bus][target];
3965 
3966 	if (ld->cl_update == 0)
3967 		continue;
3968 
3969 	ld->cl_update		= 0;
3970 	ld->cl_address		= cll->lun[i];
3971 	ld->cl_controller	= &sc->ciss_controllers[bus];
3972 	if (ciss_identify_logical(sc, ld) == 0) {
3973 	    ciss_cam_rescan_target(sc, bus, target);
3974 	}
3975     }
3976     free(cll, CISS_MALLOC_CLASS);
3977 }
3978 
3979 /************************************************************************
3980  * Handle a notify event relating to the status of a logical drive.
3981  *
3982  * XXX need to be able to defer some of these to properly handle
3983  *     calling the "ID Physical drive" command, unless the 'extended'
3984  *     drive IDs are always in BIG_MAP format.
3985  */
3986 static void
3987 ciss_notify_logical(struct ciss_softc *sc, struct ciss_notify *cn)
3988 {
3989     struct ciss_ldrive	*ld;
3990     int			ostatus, bus, target;
3991 
3992     debug_called(2);
3993 
3994     bus		= cn->device.physical.bus;
3995     target	= cn->data.logical_status.logical_drive;
3996     ld		= &sc->ciss_logical[bus][target];
3997 
3998     switch (cn->subclass) {
3999     case CISS_NOTIFY_LOGICAL_STATUS:
4000 	switch (cn->detail) {
4001 	case 0:
4002 	    ciss_name_device(sc, bus, target);
4003 	    ciss_printf(sc, "logical drive %d (%s) changed status %s->%s, spare status 0x%b\n",
4004 			cn->data.logical_status.logical_drive, ld->cl_name,
4005 			ciss_name_ldrive_status(cn->data.logical_status.previous_state),
4006 			ciss_name_ldrive_status(cn->data.logical_status.new_state),
4007 			cn->data.logical_status.spare_state,
4008 			"\20\1configured\2rebuilding\3failed\4in use\5available\n");
4009 
4010 	    /*
4011 	     * Update our idea of the drive's status.
4012 	     */
4013 	    ostatus = ciss_decode_ldrive_status(cn->data.logical_status.previous_state);
4014 	    ld->cl_status = ciss_decode_ldrive_status(cn->data.logical_status.new_state);
4015 	    if (ld->cl_lstatus != NULL)
4016 		ld->cl_lstatus->status = cn->data.logical_status.new_state;
4017 
4018 	    /*
4019 	     * Have CAM rescan the drive if its status has changed.
4020 	     */
4021 	    if (ostatus != ld->cl_status) {
4022 		ld->cl_update = 1;
4023 		ciss_notify_rescan_logical(sc);
4024 	    }
4025 
4026 	    break;
4027 
4028 	case 1:	/* logical drive has recognised new media, needs Accept Media Exchange */
4029 	    ciss_name_device(sc, bus, target);
4030 	    ciss_printf(sc, "logical drive %d (%s) media exchanged, ready to go online\n",
4031 			cn->data.logical_status.logical_drive, ld->cl_name);
4032 	    ciss_accept_media(sc, ld);
4033 
4034 	    ld->cl_update = 1;
4035 	    ld->cl_status = ciss_decode_ldrive_status(cn->data.logical_status.new_state);
4036 	    ciss_notify_rescan_logical(sc);
4037 	    break;
4038 
4039 	case 2:
4040 	case 3:
4041 	    ciss_printf(sc, "rebuild of logical drive %d (%s) failed due to %s error\n",
4042 			cn->data.rebuild_aborted.logical_drive,
4043 			ld->cl_name,
4044 			(cn->detail == 2) ? "read" : "write");
4045 	    break;
4046 	}
4047 	break;
4048 
4049     case CISS_NOTIFY_LOGICAL_ERROR:
4050 	if (cn->detail == 0) {
4051 	    ciss_printf(sc, "FATAL I/O ERROR on logical drive %d (%s), SCSI port %d ID %d\n",
4052 			cn->data.io_error.logical_drive,
4053 			ld->cl_name,
4054 			cn->data.io_error.failure_bus,
4055 			cn->data.io_error.failure_drive);
4056 	    /* XXX should we take the drive down at this point, or will we be told? */
4057 	}
4058 	break;
4059 
4060     case CISS_NOTIFY_LOGICAL_SURFACE:
4061 	if (cn->detail == 0)
4062 	    ciss_printf(sc, "logical drive %d (%s) completed consistency initialisation\n",
4063 			cn->data.consistency_completed.logical_drive,
4064 			ld->cl_name);
4065 	break;
4066     }
4067 }
4068 
4069 /************************************************************************
4070  * Handle a notify event relating to the status of a physical drive.
4071  */
4072 static void
4073 ciss_notify_physical(struct ciss_softc *sc, struct ciss_notify *cn)
4074 {
4075 }
4076 
4077 /************************************************************************
4078  * Handle a notify event relating to the status of a physical drive.
4079  */
4080 static void
4081 ciss_notify_hotplug(struct ciss_softc *sc, struct ciss_notify *cn)
4082 {
4083     struct ciss_lun_report *cll = NULL;
4084     int bus, target;
4085 
4086     switch (cn->subclass) {
4087     case CISS_NOTIFY_HOTPLUG_PHYSICAL:
4088     case CISS_NOTIFY_HOTPLUG_NONDISK:
4089 	bus = CISS_BIG_MAP_BUS(sc, cn->data.drive.big_physical_drive_number);
4090 	target =
4091 	    CISS_BIG_MAP_TARGET(sc, cn->data.drive.big_physical_drive_number);
4092 
4093 	if (cn->detail == 0) {
4094 	    /*
4095 	     * Mark the device offline so that it'll start producing selection
4096 	     * timeouts to the upper layer.
4097 	     */
4098 	    if ((bus >= 0) && (target >= 0))
4099 		sc->ciss_physical[bus][target].cp_online = 0;
4100 	} else {
4101 	    /*
4102 	     * Rescan the physical lun list for new items
4103 	     */
4104 	    cll = ciss_report_luns(sc, CISS_OPCODE_REPORT_PHYSICAL_LUNS,
4105 				   sc->ciss_cfg->max_physical_supported);
4106 	    if (cll == NULL) {
4107 		ciss_printf(sc, "Warning, cannot get physical lun list\n");
4108 		break;
4109 	    }
4110 	    ciss_filter_physical(sc, cll);
4111 	}
4112 	break;
4113 
4114     default:
4115 	ciss_printf(sc, "Unknown hotplug event %d\n", cn->subclass);
4116 	return;
4117     }
4118 
4119     if (cll != NULL)
4120 	free(cll, CISS_MALLOC_CLASS);
4121 }
4122 
4123 /************************************************************************
4124  * Handle deferred processing of notify events.  Notify events may need
4125  * sleep which is unsafe during an interrupt.
4126  */
4127 static void
4128 ciss_notify_thread(void *arg)
4129 {
4130     struct ciss_softc		*sc;
4131     struct ciss_request		*cr;
4132     struct ciss_notify		*cn;
4133 
4134     sc = (struct ciss_softc *)arg;
4135     mtx_lock(&sc->ciss_mtx);
4136 
4137     for (;;) {
4138 	if (STAILQ_EMPTY(&sc->ciss_notify) != 0 &&
4139 	    (sc->ciss_flags & CISS_FLAG_THREAD_SHUT) == 0) {
4140 	    msleep(&sc->ciss_notify, &sc->ciss_mtx, PUSER, "idle", 0);
4141 	}
4142 
4143 	if (sc->ciss_flags & CISS_FLAG_THREAD_SHUT)
4144 	    break;
4145 
4146 	cr = ciss_dequeue_notify(sc);
4147 
4148 	if (cr == NULL)
4149 		panic("cr null");
4150 	cn = (struct ciss_notify *)cr->cr_data;
4151 
4152 	switch (cn->class) {
4153 	case CISS_NOTIFY_HOTPLUG:
4154 	    ciss_notify_hotplug(sc, cn);
4155 	    break;
4156 	case CISS_NOTIFY_LOGICAL:
4157 	    ciss_notify_logical(sc, cn);
4158 	    break;
4159 	case CISS_NOTIFY_PHYSICAL:
4160 	    ciss_notify_physical(sc, cn);
4161 	    break;
4162 	}
4163 
4164 	ciss_release_request(cr);
4165     }
4166     sc->ciss_notify_thread = NULL;
4167     wakeup(&sc->ciss_notify_thread);
4168 
4169     mtx_unlock(&sc->ciss_mtx);
4170     kproc_exit(0);
4171 }
4172 
4173 /************************************************************************
4174  * Start the notification kernel thread.
4175  */
4176 static void
4177 ciss_spawn_notify_thread(struct ciss_softc *sc)
4178 {
4179 
4180     if (kproc_create((void(*)(void *))ciss_notify_thread, sc,
4181 		       &sc->ciss_notify_thread, 0, 0, "ciss_notify%d",
4182 		       device_get_unit(sc->ciss_dev)))
4183 	panic("Could not create notify thread\n");
4184 }
4185 
4186 /************************************************************************
4187  * Kill the notification kernel thread.
4188  */
4189 static void
4190 ciss_kill_notify_thread(struct ciss_softc *sc)
4191 {
4192 
4193     if (sc->ciss_notify_thread == NULL)
4194 	return;
4195 
4196     sc->ciss_flags |= CISS_FLAG_THREAD_SHUT;
4197     wakeup(&sc->ciss_notify);
4198     msleep(&sc->ciss_notify_thread, &sc->ciss_mtx, PUSER, "thtrm", 0);
4199 }
4200 
4201 /************************************************************************
4202  * Print a request.
4203  */
4204 #ifdef DDB
4205 static void
4206 ciss_print_request(struct ciss_request *cr)
4207 {
4208     struct ciss_softc	*sc;
4209     struct ciss_command	*cc;
4210     int			i;
4211 
4212     sc = cr->cr_sc;
4213     cc = cr->cr_cc;
4214 
4215     ciss_printf(sc, "REQUEST @ %p\n", cr);
4216     ciss_printf(sc, "  data %p/%d  tag %d  flags %b\n",
4217 	      cr->cr_data, cr->cr_length, cr->cr_tag, cr->cr_flags,
4218 	      "\20\1mapped\2sleep\3poll\4dataout\5datain\n");
4219     ciss_printf(sc, "  sg list/total %d/%d  host tag 0x%x\n",
4220 		cc->header.sg_in_list, cc->header.sg_total, cc->header.host_tag);
4221     switch(cc->header.address.mode.mode) {
4222     case CISS_HDR_ADDRESS_MODE_PERIPHERAL:
4223     case CISS_HDR_ADDRESS_MODE_MASK_PERIPHERAL:
4224 	ciss_printf(sc, "  physical bus %d target %d\n",
4225 		    cc->header.address.physical.bus, cc->header.address.physical.target);
4226 	break;
4227     case CISS_HDR_ADDRESS_MODE_LOGICAL:
4228 	ciss_printf(sc, "  logical unit %d\n", cc->header.address.logical.lun);
4229 	break;
4230     }
4231     ciss_printf(sc, "  %s cdb length %d type %s attribute %s\n",
4232 		(cc->cdb.direction == CISS_CDB_DIRECTION_NONE) ? "no-I/O" :
4233 		(cc->cdb.direction == CISS_CDB_DIRECTION_READ) ? "READ" :
4234 		(cc->cdb.direction == CISS_CDB_DIRECTION_WRITE) ? "WRITE" : "??",
4235 		cc->cdb.cdb_length,
4236 		(cc->cdb.type == CISS_CDB_TYPE_COMMAND) ? "command" :
4237 		(cc->cdb.type == CISS_CDB_TYPE_MESSAGE) ? "message" : "??",
4238 		(cc->cdb.attribute == CISS_CDB_ATTRIBUTE_UNTAGGED) ? "untagged" :
4239 		(cc->cdb.attribute == CISS_CDB_ATTRIBUTE_SIMPLE) ? "simple" :
4240 		(cc->cdb.attribute == CISS_CDB_ATTRIBUTE_HEAD_OF_QUEUE) ? "head-of-queue" :
4241 		(cc->cdb.attribute == CISS_CDB_ATTRIBUTE_ORDERED) ? "ordered" :
4242 		(cc->cdb.attribute == CISS_CDB_ATTRIBUTE_AUTO_CONTINGENT) ? "auto-contingent" : "??");
4243     ciss_printf(sc, "  %*D\n", cc->cdb.cdb_length, &cc->cdb.cdb[0], " ");
4244 
4245     if (cc->header.host_tag & CISS_HDR_HOST_TAG_ERROR) {
4246 	/* XXX print error info */
4247     } else {
4248 	/* since we don't use chained s/g, don't support it here */
4249 	for (i = 0; i < cc->header.sg_in_list; i++) {
4250 	    if ((i % 4) == 0)
4251 		ciss_printf(sc, "   ");
4252 	    printf("0x%08x/%d ", (u_int32_t)cc->sg[i].address, cc->sg[i].length);
4253 	    if ((((i + 1) % 4) == 0) || (i == (cc->header.sg_in_list - 1)))
4254 		printf("\n");
4255 	}
4256     }
4257 }
4258 #endif
4259 
4260 /************************************************************************
4261  * Print information about the status of a logical drive.
4262  */
4263 static void
4264 ciss_print_ldrive(struct ciss_softc *sc, struct ciss_ldrive *ld)
4265 {
4266     int		bus, target, i;
4267 
4268     if (ld->cl_lstatus == NULL) {
4269 	printf("does not exist\n");
4270 	return;
4271     }
4272 
4273     /* print drive status */
4274     switch(ld->cl_lstatus->status) {
4275     case CISS_LSTATUS_OK:
4276 	printf("online\n");
4277 	break;
4278     case CISS_LSTATUS_INTERIM_RECOVERY:
4279 	printf("in interim recovery mode\n");
4280 	break;
4281     case CISS_LSTATUS_READY_RECOVERY:
4282 	printf("ready to begin recovery\n");
4283 	break;
4284     case CISS_LSTATUS_RECOVERING:
4285 	bus = CISS_BIG_MAP_BUS(sc, ld->cl_lstatus->drive_rebuilding);
4286 	target = CISS_BIG_MAP_BUS(sc, ld->cl_lstatus->drive_rebuilding);
4287 	printf("being recovered, working on physical drive %d.%d, %u blocks remaining\n",
4288 	       bus, target, ld->cl_lstatus->blocks_to_recover);
4289 	break;
4290     case CISS_LSTATUS_EXPANDING:
4291 	printf("being expanded, %u blocks remaining\n",
4292 	       ld->cl_lstatus->blocks_to_recover);
4293 	break;
4294     case CISS_LSTATUS_QUEUED_FOR_EXPANSION:
4295 	printf("queued for expansion\n");
4296 	break;
4297     case CISS_LSTATUS_FAILED:
4298 	printf("queued for expansion\n");
4299 	break;
4300     case CISS_LSTATUS_WRONG_PDRIVE:
4301 	printf("wrong physical drive inserted\n");
4302 	break;
4303     case CISS_LSTATUS_MISSING_PDRIVE:
4304 	printf("missing a needed physical drive\n");
4305 	break;
4306     case CISS_LSTATUS_BECOMING_READY:
4307 	printf("becoming ready\n");
4308 	break;
4309     }
4310 
4311     /* print failed physical drives */
4312     for (i = 0; i < CISS_BIG_MAP_ENTRIES / 8; i++) {
4313 	bus = CISS_BIG_MAP_BUS(sc, ld->cl_lstatus->drive_failure_map[i]);
4314 	target = CISS_BIG_MAP_TARGET(sc, ld->cl_lstatus->drive_failure_map[i]);
4315 	if (bus == -1)
4316 	    continue;
4317 	ciss_printf(sc, "physical drive %d:%d (%x) failed\n", bus, target,
4318 		    ld->cl_lstatus->drive_failure_map[i]);
4319     }
4320 }
4321 
4322 #ifdef DDB
4323 #include <ddb/ddb.h>
4324 /************************************************************************
4325  * Print information about the controller/driver.
4326  */
4327 static void
4328 ciss_print_adapter(struct ciss_softc *sc)
4329 {
4330     int		i, j;
4331 
4332     ciss_printf(sc, "ADAPTER:\n");
4333     for (i = 0; i < CISSQ_COUNT; i++) {
4334 	ciss_printf(sc, "%s     %d/%d\n",
4335 	    i == 0 ? "free" :
4336 	    i == 1 ? "busy" : "complete",
4337 	    sc->ciss_qstat[i].q_length,
4338 	    sc->ciss_qstat[i].q_max);
4339     }
4340     ciss_printf(sc, "max_requests %d\n", sc->ciss_max_requests);
4341     ciss_printf(sc, "flags %b\n", sc->ciss_flags,
4342 	"\20\1notify_ok\2control_open\3aborting\4running\21fake_synch\22bmic_abort\n");
4343 
4344     for (i = 0; i < sc->ciss_max_logical_bus; i++) {
4345 	for (j = 0; j < sc->ciss_cfg->max_logical_supported; j++) {
4346 	    ciss_printf(sc, "LOGICAL DRIVE %d:  ", i);
4347 	    ciss_print_ldrive(sc, &sc->ciss_logical[i][j]);
4348 	}
4349     }
4350 
4351     /* XXX Should physical drives be printed out here? */
4352 
4353     for (i = 1; i < sc->ciss_max_requests; i++)
4354 	ciss_print_request(sc->ciss_request + i);
4355 }
4356 
4357 /* DDB hook */
4358 DB_COMMAND(ciss_prt, db_ciss_prt)
4359 {
4360     struct ciss_softc	*sc;
4361     devclass_t dc;
4362     int maxciss, i;
4363 
4364     dc = devclass_find("ciss");
4365     if ( dc == NULL ) {
4366         printf("%s: can't find devclass!\n", __func__);
4367         return;
4368     }
4369     maxciss = devclass_get_maxunit(dc);
4370     for (i = 0; i < maxciss; i++) {
4371         sc = devclass_get_softc(dc, i);
4372 	ciss_print_adapter(sc);
4373     }
4374 }
4375 #endif
4376 
4377 /************************************************************************
4378  * Return a name for a logical drive status value.
4379  */
4380 static const char *
4381 ciss_name_ldrive_status(int status)
4382 {
4383     switch (status) {
4384     case CISS_LSTATUS_OK:
4385 	return("OK");
4386     case CISS_LSTATUS_FAILED:
4387 	return("failed");
4388     case CISS_LSTATUS_NOT_CONFIGURED:
4389 	return("not configured");
4390     case CISS_LSTATUS_INTERIM_RECOVERY:
4391 	return("interim recovery");
4392     case CISS_LSTATUS_READY_RECOVERY:
4393 	return("ready for recovery");
4394     case CISS_LSTATUS_RECOVERING:
4395 	return("recovering");
4396     case CISS_LSTATUS_WRONG_PDRIVE:
4397 	return("wrong physical drive inserted");
4398     case CISS_LSTATUS_MISSING_PDRIVE:
4399 	return("missing physical drive");
4400     case CISS_LSTATUS_EXPANDING:
4401 	return("expanding");
4402     case CISS_LSTATUS_BECOMING_READY:
4403 	return("becoming ready");
4404     case CISS_LSTATUS_QUEUED_FOR_EXPANSION:
4405 	return("queued for expansion");
4406     }
4407     return("unknown status");
4408 }
4409 
4410 /************************************************************************
4411  * Return an online/offline/nonexistent value for a logical drive
4412  * status value.
4413  */
4414 static int
4415 ciss_decode_ldrive_status(int status)
4416 {
4417     switch(status) {
4418     case CISS_LSTATUS_NOT_CONFIGURED:
4419 	return(CISS_LD_NONEXISTENT);
4420 
4421     case CISS_LSTATUS_OK:
4422     case CISS_LSTATUS_INTERIM_RECOVERY:
4423     case CISS_LSTATUS_READY_RECOVERY:
4424     case CISS_LSTATUS_RECOVERING:
4425     case CISS_LSTATUS_EXPANDING:
4426     case CISS_LSTATUS_QUEUED_FOR_EXPANSION:
4427 	return(CISS_LD_ONLINE);
4428 
4429     case CISS_LSTATUS_FAILED:
4430     case CISS_LSTATUS_WRONG_PDRIVE:
4431     case CISS_LSTATUS_MISSING_PDRIVE:
4432     case CISS_LSTATUS_BECOMING_READY:
4433     default:
4434 	return(CISS_LD_OFFLINE);
4435     }
4436 }
4437 
4438 /************************************************************************
4439  * Return a name for a logical drive's organisation.
4440  */
4441 static const char *
4442 ciss_name_ldrive_org(int org)
4443 {
4444     switch(org) {
4445     case CISS_LDRIVE_RAID0:
4446 	return("RAID 0");
4447     case CISS_LDRIVE_RAID1:
4448 	return("RAID 1(1+0)");
4449     case CISS_LDRIVE_RAID4:
4450 	return("RAID 4");
4451     case CISS_LDRIVE_RAID5:
4452 	return("RAID 5");
4453     case CISS_LDRIVE_RAID51:
4454 	return("RAID 5+1");
4455     case CISS_LDRIVE_RAIDADG:
4456 	return("RAID ADG");
4457     }
4458     return("unknown");
4459 }
4460 
4461 /************************************************************************
4462  * Return a name for a command status value.
4463  */
4464 static const char *
4465 ciss_name_command_status(int status)
4466 {
4467     switch(status) {
4468     case CISS_CMD_STATUS_SUCCESS:
4469 	return("success");
4470     case CISS_CMD_STATUS_TARGET_STATUS:
4471 	return("target status");
4472     case CISS_CMD_STATUS_DATA_UNDERRUN:
4473 	return("data underrun");
4474     case CISS_CMD_STATUS_DATA_OVERRUN:
4475 	return("data overrun");
4476     case CISS_CMD_STATUS_INVALID_COMMAND:
4477 	return("invalid command");
4478     case CISS_CMD_STATUS_PROTOCOL_ERROR:
4479 	return("protocol error");
4480     case CISS_CMD_STATUS_HARDWARE_ERROR:
4481 	return("hardware error");
4482     case CISS_CMD_STATUS_CONNECTION_LOST:
4483 	return("connection lost");
4484     case CISS_CMD_STATUS_ABORTED:
4485 	return("aborted");
4486     case CISS_CMD_STATUS_ABORT_FAILED:
4487 	return("abort failed");
4488     case CISS_CMD_STATUS_UNSOLICITED_ABORT:
4489 	return("unsolicited abort");
4490     case CISS_CMD_STATUS_TIMEOUT:
4491 	return("timeout");
4492     case CISS_CMD_STATUS_UNABORTABLE:
4493 	return("unabortable");
4494     }
4495     return("unknown status");
4496 }
4497 
4498 /************************************************************************
4499  * Handle an open on the control device.
4500  */
4501 static int
4502 ciss_open(struct cdev *dev, int flags, int fmt, struct thread *p)
4503 {
4504     struct ciss_softc	*sc;
4505 
4506     debug_called(1);
4507 
4508     sc = (struct ciss_softc *)dev->si_drv1;
4509 
4510     /* we might want to veto if someone already has us open */
4511 
4512     mtx_lock(&sc->ciss_mtx);
4513     sc->ciss_flags |= CISS_FLAG_CONTROL_OPEN;
4514     mtx_unlock(&sc->ciss_mtx);
4515     return(0);
4516 }
4517 
4518 /************************************************************************
4519  * Handle the last close on the control device.
4520  */
4521 static int
4522 ciss_close(struct cdev *dev, int flags, int fmt, struct thread *p)
4523 {
4524     struct ciss_softc	*sc;
4525 
4526     debug_called(1);
4527 
4528     sc = (struct ciss_softc *)dev->si_drv1;
4529 
4530     mtx_lock(&sc->ciss_mtx);
4531     sc->ciss_flags &= ~CISS_FLAG_CONTROL_OPEN;
4532     mtx_unlock(&sc->ciss_mtx);
4533     return (0);
4534 }
4535 
4536 /********************************************************************************
4537  * Handle adapter-specific control operations.
4538  *
4539  * Note that the API here is compatible with the Linux driver, in order to
4540  * simplify the porting of Compaq's userland tools.
4541  */
4542 static int
4543 ciss_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int32_t flag, struct thread *p)
4544 {
4545     struct ciss_softc		*sc;
4546     IOCTL_Command_struct	*ioc	= (IOCTL_Command_struct *)addr;
4547 #ifdef __amd64__
4548     IOCTL_Command_struct32	*ioc32	= (IOCTL_Command_struct32 *)addr;
4549     IOCTL_Command_struct	ioc_swab;
4550 #endif
4551     int				error;
4552 
4553     debug_called(1);
4554 
4555     sc = (struct ciss_softc *)dev->si_drv1;
4556     error = 0;
4557     mtx_lock(&sc->ciss_mtx);
4558 
4559     switch(cmd) {
4560     case CCISS_GETQSTATS:
4561     {
4562 	union ciss_statrequest *cr = (union ciss_statrequest *)addr;
4563 
4564 	switch (cr->cs_item) {
4565 	case CISSQ_FREE:
4566 	case CISSQ_NOTIFY:
4567 	    bcopy(&sc->ciss_qstat[cr->cs_item], &cr->cs_qstat,
4568 		sizeof(struct ciss_qstat));
4569 	    break;
4570 	default:
4571 	    error = ENOIOCTL;
4572 	    break;
4573 	}
4574 
4575 	break;
4576     }
4577 
4578     case CCISS_GETPCIINFO:
4579     {
4580 	cciss_pci_info_struct	*pis = (cciss_pci_info_struct *)addr;
4581 
4582 	pis->bus = pci_get_bus(sc->ciss_dev);
4583 	pis->dev_fn = pci_get_slot(sc->ciss_dev);
4584         pis->board_id = (pci_get_subvendor(sc->ciss_dev) << 16) |
4585                 pci_get_subdevice(sc->ciss_dev);
4586 
4587 	break;
4588     }
4589 
4590     case CCISS_GETINTINFO:
4591     {
4592 	cciss_coalint_struct	*cis = (cciss_coalint_struct *)addr;
4593 
4594 	cis->delay = sc->ciss_cfg->interrupt_coalesce_delay;
4595 	cis->count = sc->ciss_cfg->interrupt_coalesce_count;
4596 
4597 	break;
4598     }
4599 
4600     case CCISS_SETINTINFO:
4601     {
4602 	cciss_coalint_struct	*cis = (cciss_coalint_struct *)addr;
4603 
4604 	if ((cis->delay == 0) && (cis->count == 0)) {
4605 	    error = EINVAL;
4606 	    break;
4607 	}
4608 
4609 	/*
4610 	 * XXX apparently this is only safe if the controller is idle,
4611 	 *     we should suspend it before doing this.
4612 	 */
4613 	sc->ciss_cfg->interrupt_coalesce_delay = cis->delay;
4614 	sc->ciss_cfg->interrupt_coalesce_count = cis->count;
4615 
4616 	if (ciss_update_config(sc))
4617 	    error = EIO;
4618 
4619 	/* XXX resume the controller here */
4620 	break;
4621     }
4622 
4623     case CCISS_GETNODENAME:
4624 	bcopy(sc->ciss_cfg->server_name, (NodeName_type *)addr,
4625 	      sizeof(NodeName_type));
4626 	break;
4627 
4628     case CCISS_SETNODENAME:
4629 	bcopy((NodeName_type *)addr, sc->ciss_cfg->server_name,
4630 	      sizeof(NodeName_type));
4631 	if (ciss_update_config(sc))
4632 	    error = EIO;
4633 	break;
4634 
4635     case CCISS_GETHEARTBEAT:
4636 	*(Heartbeat_type *)addr = sc->ciss_cfg->heartbeat;
4637 	break;
4638 
4639     case CCISS_GETBUSTYPES:
4640 	*(BusTypes_type *)addr = sc->ciss_cfg->bus_types;
4641 	break;
4642 
4643     case CCISS_GETFIRMVER:
4644 	bcopy(sc->ciss_id->running_firmware_revision, (FirmwareVer_type *)addr,
4645 	      sizeof(FirmwareVer_type));
4646 	break;
4647 
4648     case CCISS_GETDRIVERVER:
4649 	*(DriverVer_type *)addr = CISS_DRIVER_VERSION;
4650 	break;
4651 
4652     case CCISS_REVALIDVOLS:
4653 	/*
4654 	 * This is a bit ugly; to do it "right" we really need
4655 	 * to find any disks that have changed, kick CAM off them,
4656 	 * then rescan only these disks.  It'd be nice if they
4657 	 * a) told us which disk(s) they were going to play with,
4658 	 * and b) which ones had arrived. 8(
4659 	 */
4660 	break;
4661 
4662 #ifdef __amd64__
4663     case CCISS_PASSTHRU32:
4664 	ioc_swab.LUN_info	= ioc32->LUN_info;
4665 	ioc_swab.Request	= ioc32->Request;
4666 	ioc_swab.error_info	= ioc32->error_info;
4667 	ioc_swab.buf_size	= ioc32->buf_size;
4668 	ioc_swab.buf		= (u_int8_t *)(uintptr_t)ioc32->buf;
4669 	ioc			= &ioc_swab;
4670 	/* FALLTHROUGH */
4671 #endif
4672 
4673     case CCISS_PASSTHRU:
4674 	error = ciss_user_command(sc, ioc);
4675 	break;
4676 
4677     default:
4678 	debug(0, "unknown ioctl 0x%lx", cmd);
4679 
4680 	debug(1, "CCISS_GETPCIINFO:   0x%lx", CCISS_GETPCIINFO);
4681 	debug(1, "CCISS_GETINTINFO:   0x%lx", CCISS_GETINTINFO);
4682 	debug(1, "CCISS_SETINTINFO:   0x%lx", CCISS_SETINTINFO);
4683 	debug(1, "CCISS_GETNODENAME:  0x%lx", CCISS_GETNODENAME);
4684 	debug(1, "CCISS_SETNODENAME:  0x%lx", CCISS_SETNODENAME);
4685 	debug(1, "CCISS_GETHEARTBEAT: 0x%lx", CCISS_GETHEARTBEAT);
4686 	debug(1, "CCISS_GETBUSTYPES:  0x%lx", CCISS_GETBUSTYPES);
4687 	debug(1, "CCISS_GETFIRMVER:   0x%lx", CCISS_GETFIRMVER);
4688 	debug(1, "CCISS_GETDRIVERVER: 0x%lx", CCISS_GETDRIVERVER);
4689 	debug(1, "CCISS_REVALIDVOLS:  0x%lx", CCISS_REVALIDVOLS);
4690 	debug(1, "CCISS_PASSTHRU:     0x%lx", CCISS_PASSTHRU);
4691 
4692 	error = ENOIOCTL;
4693 	break;
4694     }
4695 
4696     mtx_unlock(&sc->ciss_mtx);
4697     return(error);
4698 }
4699