2 * Copyright (c) 2001 Michael Smith
3 * Copyright (c) 2004 Paul Saab
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * $FreeBSD: src/sys/dev/ciss/ciss.c,v 1.2.2.25 2008/06/10 18:51:05 ps Exp $
28 * $DragonFly: src/sys/dev/raid/ciss/ciss.c,v 1.28 2008/05/18 20:30:23 pavalos Exp $
32 * Common Interface for SCSI-3 Support driver.
34 * CISS claims to provide a common interface between a generic SCSI
35 * transport and an intelligent host adapter.
37 * This driver supports CISS as defined in the document "CISS Command
38 * Interface for SCSI-3 Support Open Specification", Version 1.04,
39 * Valence Number 1, dated 20001127, produced by Compaq Computer
40 * Corporation. This document appears to be a hastily and somewhat
41 * arbitrarlily cut-down version of a larger (and probably even more
42 * chaotic and inconsistent) Compaq internal document. Various
43 * details were also gleaned from Compaq's "cciss" driver for Linux.
45 * We provide a shim layer between the CISS interface and CAM,
46 * offloading most of the queueing and being-a-disk chores onto CAM.
47 * Entry to the driver is via the PCI bus attachment (ciss_probe,
48 * ciss_attach, etc) and via the CAM interface (ciss_cam_action,
49 * ciss_cam_poll). The Compaq CISS adapters are, however, poor SCSI
50 * citizens and we have to fake up some responses to get reasonable
51 * behaviour out of them. In addition, the CISS command set is by no
52 * means adequate to support the functionality of a RAID controller,
53 * and thus the supported Compaq adapters utilise portions of the
54 * control protocol from earlier Compaq adapter families.
56 * Note that we only support the "simple" transport layer over PCI.
57 * This interface (ab)uses the I2O register set (specifically the post
58 * queues) to exchange commands with the adapter. Other interfaces
59 * are available, but we aren't supposed to know about them, and it is
60 * dubious whether they would provide major performance improvements
61 * except under extreme load.
63 * Currently the only supported CISS adapters are the Compaq Smart
64 * Array 5* series (5300, 5i, 532). Even with only three adapters,
65 * Compaq still manage to have interface variations.
68 * Thanks must go to Fred Harris and Darryl DeVinney at Compaq, as
69 * well as Paul Saab at Yahoo! for their assistance in making this
72 * More thanks must go to John Cagle at HP for the countless hours
73 * spent making this driver "work" with the MSA* series storage
74 * enclosures. Without his help (and nagging), this driver could not
75 * be used with these enclosures.
78 #include <sys/param.h>
79 #include <sys/systm.h>
80 #include <sys/device.h>
81 #include <sys/malloc.h>
82 #include <sys/kernel.h>
85 #include <sys/devicestat.h>
87 #include <sys/kthread.h>
88 #include <sys/queue.h>
91 #include <bus/cam/cam.h>
92 #include <bus/cam/cam_ccb.h>
93 #include <bus/cam/cam_periph.h>
94 #include <bus/cam/cam_sim.h>
95 #include <bus/cam/cam_xpt_sim.h>
96 #include <bus/cam/scsi/scsi_all.h>
97 #include <bus/cam/scsi/scsi_message.h>
99 #include <machine/clock.h>
100 #include <machine/endian.h>
102 #include <bus/pci/pcireg.h>
103 #include <bus/pci/pcivar.h>
109 MALLOC_DEFINE(CISS_MALLOC_CLASS
, "ciss_data", "ciss internal data buffers");
112 static int ciss_lookup(device_t dev
);
113 static int ciss_probe(device_t dev
);
114 static int ciss_attach(device_t dev
);
115 static int ciss_detach(device_t dev
);
116 static int ciss_shutdown(device_t dev
);
118 /* (de)initialisation functions, control wrappers */
119 static int ciss_init_pci(struct ciss_softc
*sc
);
120 static int ciss_wait_adapter(struct ciss_softc
*sc
);
121 static int ciss_flush_adapter(struct ciss_softc
*sc
);
122 static int ciss_init_requests(struct ciss_softc
*sc
);
123 static void ciss_command_map_helper(void *arg
, bus_dma_segment_t
*segs
,
124 int nseg
, int error
);
125 static int ciss_identify_adapter(struct ciss_softc
*sc
);
126 static int ciss_init_logical(struct ciss_softc
*sc
);
127 static int ciss_init_physical(struct ciss_softc
*sc
);
128 static int ciss_filter_physical(struct ciss_softc
*sc
, struct ciss_lun_report
*cll
);
129 static int ciss_identify_logical(struct ciss_softc
*sc
, struct ciss_ldrive
*ld
);
130 static int ciss_get_ldrive_status(struct ciss_softc
*sc
, struct ciss_ldrive
*ld
);
131 static int ciss_update_config(struct ciss_softc
*sc
);
132 static int ciss_accept_media(struct ciss_softc
*sc
, struct ciss_ldrive
*ld
);
133 static void ciss_free(struct ciss_softc
*sc
);
134 static void ciss_spawn_notify_thread(struct ciss_softc
*sc
);
135 static void ciss_kill_notify_thread(struct ciss_softc
*sc
);
137 /* request submission/completion */
138 static int ciss_start(struct ciss_request
*cr
);
139 static void ciss_done(struct ciss_softc
*sc
);
140 static void ciss_intr(void *arg
);
141 static void ciss_complete(struct ciss_softc
*sc
);
142 static int ciss_report_request(struct ciss_request
*cr
, int *command_status
,
144 static int ciss_synch_request(struct ciss_request
*cr
, int timeout
);
145 static int ciss_poll_request(struct ciss_request
*cr
, int timeout
);
146 static int ciss_wait_request(struct ciss_request
*cr
, int timeout
);
148 static int ciss_abort_request(struct ciss_request
*cr
);
151 /* request queueing */
152 static int ciss_get_request(struct ciss_softc
*sc
, struct ciss_request
**crp
);
153 static void ciss_preen_command(struct ciss_request
*cr
);
154 static void ciss_release_request(struct ciss_request
*cr
);
156 /* request helpers */
157 static int ciss_get_bmic_request(struct ciss_softc
*sc
, struct ciss_request
**crp
,
158 int opcode
, void **bufp
, size_t bufsize
);
159 static int ciss_user_command(struct ciss_softc
*sc
, IOCTL_Command_struct
*ioc
);
162 static int ciss_map_request(struct ciss_request
*cr
);
163 static void ciss_request_map_helper(void *arg
, bus_dma_segment_t
*segs
,
164 int nseg
, int error
);
165 static void ciss_unmap_request(struct ciss_request
*cr
);
168 static int ciss_cam_init(struct ciss_softc
*sc
);
169 static void ciss_cam_rescan_target(struct ciss_softc
*sc
,
170 int bus
, int target
);
171 static void ciss_cam_rescan_all(struct ciss_softc
*sc
);
172 static void ciss_cam_rescan_callback(struct cam_periph
*periph
, union ccb
*ccb
);
173 static void ciss_cam_action(struct cam_sim
*sim
, union ccb
*ccb
);
174 static int ciss_cam_action_io(struct cam_sim
*sim
, struct ccb_scsiio
*csio
);
175 static int ciss_cam_emulate(struct ciss_softc
*sc
, struct ccb_scsiio
*csio
);
176 static void ciss_cam_poll(struct cam_sim
*sim
);
177 static void ciss_cam_complete(struct ciss_request
*cr
);
178 static void ciss_cam_complete_fixup(struct ciss_softc
*sc
, struct ccb_scsiio
*csio
);
179 static struct cam_periph
*ciss_find_periph(struct ciss_softc
*sc
,
180 int bus
, int target
);
181 static int ciss_name_device(struct ciss_softc
*sc
, int bus
, int target
);
183 /* periodic status monitoring */
184 static void ciss_periodic(void *arg
);
185 static void ciss_notify_event(struct ciss_softc
*sc
);
186 static void ciss_notify_complete(struct ciss_request
*cr
);
187 static int ciss_notify_abort(struct ciss_softc
*sc
);
188 static int ciss_notify_abort_bmic(struct ciss_softc
*sc
);
189 static void ciss_notify_hotplug(struct ciss_softc
*sc
, struct ciss_notify
*cn
);
190 static void ciss_notify_logical(struct ciss_softc
*sc
, struct ciss_notify
*cn
);
191 static void ciss_notify_physical(struct ciss_softc
*sc
, struct ciss_notify
*cn
);
193 /* debugging output */
194 static void ciss_print_request(struct ciss_request
*cr
);
195 static void ciss_print_ldrive(struct ciss_softc
*sc
, struct ciss_ldrive
*ld
);
196 static const char *ciss_name_ldrive_status(int status
);
197 static int ciss_decode_ldrive_status(int status
);
198 static const char *ciss_name_ldrive_org(int org
);
199 static const char *ciss_name_command_status(int status
);
204 static device_method_t ciss_methods
[] = {
205 /* Device interface */
206 DEVMETHOD(device_probe
, ciss_probe
),
207 DEVMETHOD(device_attach
, ciss_attach
),
208 DEVMETHOD(device_detach
, ciss_detach
),
209 DEVMETHOD(device_shutdown
, ciss_shutdown
),
213 static driver_t ciss_pci_driver
= {
216 sizeof(struct ciss_softc
)
219 static devclass_t ciss_devclass
;
221 DECLARE_DUMMY_MODULE(ciss
);
222 DRIVER_MODULE(ciss
, pci
, ciss_pci_driver
, ciss_devclass
, 0, 0);
225 * Control device interface.
227 static d_open_t ciss_open
;
228 static d_close_t ciss_close
;
229 static d_ioctl_t ciss_ioctl
;
231 #define CISS_CDEV_MAJOR 166
233 static struct dev_ops ciss_ops
= {
234 { "ciss", CISS_CDEV_MAJOR
, 0 },
236 .d_close
= ciss_close
,
237 .d_ioctl
= ciss_ioctl
241 * This tunable can be set at boot time and controls whether physical devices
242 * that are marked hidden by the firmware should be exposed anyways.
244 static unsigned int ciss_expose_hidden_physical
= 0;
245 TUNABLE_INT("hw.ciss.expose_hidden_physical", &ciss_expose_hidden_physical
);
247 /************************************************************************
248 * CISS adapters amazingly don't have a defined programming interface
249 * value. (One could say some very despairing things about PCI and
250 * people just not getting the general idea.) So we are forced to
251 * stick with matching against subvendor/subdevice, and thus have to
252 * be updated for every new CISS adapter that appears.
254 #define CISS_BOARD_SA5 (1<<0)
255 #define CISS_BOARD_SA5B (1<<1)
263 } ciss_vendor_data
[] = {
264 { 0x0e11, 0x4070, CISS_BOARD_SA5
, "Compaq Smart Array 5300" },
265 { 0x0e11, 0x4080, CISS_BOARD_SA5B
, "Compaq Smart Array 5i" },
266 { 0x0e11, 0x4082, CISS_BOARD_SA5B
, "Compaq Smart Array 532" },
267 { 0x0e11, 0x4083, CISS_BOARD_SA5B
, "HP Smart Array 5312" },
268 { 0x0e11, 0x4091, CISS_BOARD_SA5
, "HP Smart Array 6i" },
269 { 0x0e11, 0x409A, CISS_BOARD_SA5
, "HP Smart Array 641" },
270 { 0x0e11, 0x409B, CISS_BOARD_SA5
, "HP Smart Array 642" },
271 { 0x0e11, 0x409C, CISS_BOARD_SA5
, "HP Smart Array 6400" },
272 { 0x0e11, 0x409D, CISS_BOARD_SA5
, "HP Smart Array 6400 EM" },
273 { 0x103C, 0x3211, CISS_BOARD_SA5
, "HP Smart Array E200i" },
274 { 0x103C, 0x3212, CISS_BOARD_SA5
, "HP Smart Array E200" },
275 { 0x103C, 0x3213, CISS_BOARD_SA5
, "HP Smart Array E200i" },
276 { 0x103C, 0x3214, CISS_BOARD_SA5
, "HP Smart Array E200i" },
277 { 0x103C, 0x3215, CISS_BOARD_SA5
, "HP Smart Array E200i" },
278 { 0x103C, 0x3220, CISS_BOARD_SA5
, "HP Smart Array" },
279 { 0x103C, 0x3222, CISS_BOARD_SA5
, "HP Smart Array" },
280 { 0x103C, 0x3223, CISS_BOARD_SA5
, "HP Smart Array P800" },
281 { 0x103C, 0x3225, CISS_BOARD_SA5
, "HP Smart Array P600" },
282 { 0x103C, 0x3230, CISS_BOARD_SA5
, "HP Smart Array" },
283 { 0x103C, 0x3231, CISS_BOARD_SA5
, "HP Smart Array" },
284 { 0x103C, 0x3232, CISS_BOARD_SA5
, "HP Smart Array" },
285 { 0x103C, 0x3233, CISS_BOARD_SA5
, "HP Smart Array" },
286 { 0x103C, 0x3234, CISS_BOARD_SA5
, "HP Smart Array P400" },
287 { 0x103C, 0x3235, CISS_BOARD_SA5
, "HP Smart Array P400i" },
288 { 0x103C, 0x3236, CISS_BOARD_SA5
, "HP Smart Array" },
289 { 0x103C, 0x3237, CISS_BOARD_SA5
, "HP Smart Array" },
290 { 0x103C, 0x3238, CISS_BOARD_SA5
, "HP Smart Array" },
291 { 0x103C, 0x3239, CISS_BOARD_SA5
, "HP Smart Array" },
292 { 0x103C, 0x323A, CISS_BOARD_SA5
, "HP Smart Array" },
293 { 0x103C, 0x323B, CISS_BOARD_SA5
, "HP Smart Array" },
294 { 0x103C, 0x323C, CISS_BOARD_SA5
, "HP Smart Array" },
295 { 0x103C, 0x3241, CISS_BOARD_SA5
, "HP Smart Array P212" },
296 { 0x103C, 0x3243, CISS_BOARD_SA5
, "HP Smart Array P410" },
297 { 0x103C, 0x3245, CISS_BOARD_SA5
, "HP Smart Array P410i" },
298 { 0x103C, 0x3247, CISS_BOARD_SA5
, "HP Smart Array P411" },
299 { 0x103C, 0x3249, CISS_BOARD_SA5
, "HP Smart Array P812" },
303 /************************************************************************
304 * Find a match for the device in our list of known adapters.
307 ciss_lookup(device_t dev
)
311 for (i
= 0; ciss_vendor_data
[i
].desc
!= NULL
; i
++)
312 if ((pci_get_subvendor(dev
) == ciss_vendor_data
[i
].subvendor
) &&
313 (pci_get_subdevice(dev
) == ciss_vendor_data
[i
].subdevice
)) {
319 /************************************************************************
320 * Match a known CISS adapter.
323 ciss_probe(device_t dev
)
327 i
= ciss_lookup(dev
);
329 device_set_desc(dev
, ciss_vendor_data
[i
].desc
);
335 /************************************************************************
336 * Attach the driver to this adapter.
339 ciss_attach(device_t dev
)
341 struct ciss_softc
*sc
;
347 /* print structure/union sizes */
348 debug_struct(ciss_command
);
349 debug_struct(ciss_header
);
350 debug_union(ciss_device_address
);
351 debug_struct(ciss_cdb
);
352 debug_struct(ciss_report_cdb
);
353 debug_struct(ciss_notify_cdb
);
354 debug_struct(ciss_notify
);
355 debug_struct(ciss_message_cdb
);
356 debug_struct(ciss_error_info_pointer
);
357 debug_struct(ciss_error_info
);
358 debug_struct(ciss_sg_entry
);
359 debug_struct(ciss_config_table
);
360 debug_struct(ciss_bmic_cdb
);
361 debug_struct(ciss_bmic_id_ldrive
);
362 debug_struct(ciss_bmic_id_lstatus
);
363 debug_struct(ciss_bmic_id_table
);
364 debug_struct(ciss_bmic_id_pdrive
);
365 debug_struct(ciss_bmic_blink_pdrive
);
366 debug_struct(ciss_bmic_flush_cache
);
367 debug_const(CISS_MAX_REQUESTS
);
368 debug_const(CISS_MAX_LOGICAL
);
369 debug_const(CISS_INTERRUPT_COALESCE_DELAY
);
370 debug_const(CISS_INTERRUPT_COALESCE_COUNT
);
371 debug_const(CISS_COMMAND_ALLOC_SIZE
);
372 debug_const(CISS_COMMAND_SG_LENGTH
);
374 debug_type(cciss_pci_info_struct
);
375 debug_type(cciss_coalint_struct
);
376 debug_type(cciss_coalint_struct
);
377 debug_type(NodeName_type
);
378 debug_type(NodeName_type
);
379 debug_type(Heartbeat_type
);
380 debug_type(BusTypes_type
);
381 debug_type(FirmwareVer_type
);
382 debug_type(DriverVer_type
);
383 debug_type(IOCTL_Command_struct
);
386 sc
= device_get_softc(dev
);
388 callout_init(&sc
->ciss_periodic
);
391 * Work out adapter type.
393 i
= ciss_lookup(dev
);
394 if (ciss_vendor_data
[i
].flags
& CISS_BOARD_SA5
) {
395 sc
->ciss_interrupt_mask
= CISS_TL_SIMPLE_INTR_OPQ_SA5
;
396 } else if (ciss_vendor_data
[i
].flags
& CISS_BOARD_SA5B
) {
397 sc
->ciss_interrupt_mask
= CISS_TL_SIMPLE_INTR_OPQ_SA5B
;
399 /* really an error on our part */
400 ciss_printf(sc
, "unable to determine hardware type\n");
406 * Do PCI-specific init.
408 if ((error
= ciss_init_pci(sc
)) != 0)
412 * Initialise driver queues.
416 ciss_initq_complete(sc
);
417 ciss_initq_notify(sc
);
420 * Initialise command/request pool.
422 if ((error
= ciss_init_requests(sc
)) != 0)
426 * Get adapter information.
428 if ((error
= ciss_identify_adapter(sc
)) != 0)
432 * Find all the physical devices.
434 if ((error
= ciss_init_physical(sc
)) != 0)
438 * Build our private table of logical devices.
440 if ((error
= ciss_init_logical(sc
)) != 0)
444 * Enable interrupts so that the CAM scan can complete.
446 CISS_TL_SIMPLE_ENABLE_INTERRUPTS(sc
);
449 * Initialise the CAM interface.
451 if ((error
= ciss_cam_init(sc
)) != 0)
455 * Start the heartbeat routine and event chain.
460 * Create the control device.
462 dev_ops_add(&ciss_ops
, -1, device_get_unit(sc
->ciss_dev
));
463 sc
->ciss_dev_t
= make_dev(&ciss_ops
, device_get_unit(sc
->ciss_dev
),
464 UID_ROOT
, GID_OPERATOR
, S_IRUSR
| S_IWUSR
,
465 "ciss%d", device_get_unit(sc
->ciss_dev
));
466 sc
->ciss_dev_t
->si_drv1
= sc
;
469 * The adapter is running; synchronous commands can now sleep
470 * waiting for an interrupt to signal completion.
472 sc
->ciss_flags
|= CISS_FLAG_RUNNING
;
474 ciss_spawn_notify_thread(sc
);
483 /************************************************************************
484 * Detach the driver from this adapter.
487 ciss_detach(device_t dev
)
489 struct ciss_softc
*sc
= device_get_softc(dev
);
493 if (sc
->ciss_flags
& CISS_FLAG_CONTROL_OPEN
)
496 /* flush adapter cache */
497 ciss_flush_adapter(sc
);
499 /* release all resources */
505 /************************************************************************
506 * Prepare adapter for system shutdown.
509 ciss_shutdown(device_t dev
)
511 struct ciss_softc
*sc
= device_get_softc(dev
);
515 /* flush adapter cache */
516 ciss_flush_adapter(sc
);
521 /************************************************************************
522 * Perform PCI-specific attachment actions.
525 ciss_init_pci(struct ciss_softc
*sc
)
527 uintptr_t cbase
, csize
, cofs
;
533 * Allocate register window first (we need this to find the config
537 sc
->ciss_regs_rid
= CISS_TL_SIMPLE_BAR_REGS
;
538 if ((sc
->ciss_regs_resource
=
539 bus_alloc_resource(sc
->ciss_dev
, SYS_RES_MEMORY
, &sc
->ciss_regs_rid
,
540 0, ~0, 1, RF_ACTIVE
)) == NULL
) {
541 ciss_printf(sc
, "can't allocate register window\n");
544 sc
->ciss_regs_bhandle
= rman_get_bushandle(sc
->ciss_regs_resource
);
545 sc
->ciss_regs_btag
= rman_get_bustag(sc
->ciss_regs_resource
);
548 * Find the BAR holding the config structure. If it's not the one
549 * we already mapped for registers, map it too.
551 sc
->ciss_cfg_rid
= CISS_TL_SIMPLE_READ(sc
, CISS_TL_SIMPLE_CFG_BAR
) & 0xffff;
552 if (sc
->ciss_cfg_rid
!= sc
->ciss_regs_rid
) {
553 if ((sc
->ciss_cfg_resource
=
554 bus_alloc_resource(sc
->ciss_dev
, SYS_RES_MEMORY
, &sc
->ciss_cfg_rid
,
555 0, ~0, 1, RF_ACTIVE
)) == NULL
) {
556 ciss_printf(sc
, "can't allocate config window\n");
559 cbase
= (uintptr_t)rman_get_virtual(sc
->ciss_cfg_resource
);
560 csize
= rman_get_end(sc
->ciss_cfg_resource
) -
561 rman_get_start(sc
->ciss_cfg_resource
) + 1;
563 cbase
= (uintptr_t)rman_get_virtual(sc
->ciss_regs_resource
);
564 csize
= rman_get_end(sc
->ciss_regs_resource
) -
565 rman_get_start(sc
->ciss_regs_resource
) + 1;
567 cofs
= CISS_TL_SIMPLE_READ(sc
, CISS_TL_SIMPLE_CFG_OFF
);
570 * Use the base/size/offset values we just calculated to
571 * sanity-check the config structure. If it's OK, point to it.
573 if ((cofs
+ sizeof(struct ciss_config_table
)) > csize
) {
574 ciss_printf(sc
, "config table outside window\n");
577 sc
->ciss_cfg
= (struct ciss_config_table
*)(cbase
+ cofs
);
578 debug(1, "config struct at %p", sc
->ciss_cfg
);
581 * Validate the config structure. If we supported other transport
582 * methods, we could select amongst them at this point in time.
584 if (strncmp(sc
->ciss_cfg
->signature
, "CISS", 4)) {
585 ciss_printf(sc
, "config signature mismatch (got '%c%c%c%c')\n",
586 sc
->ciss_cfg
->signature
[0], sc
->ciss_cfg
->signature
[1],
587 sc
->ciss_cfg
->signature
[2], sc
->ciss_cfg
->signature
[3]);
592 * Put the board into simple mode, and tell it we're using the low
593 * 4GB of RAM. Set the default interrupt coalescing options.
595 if (!(sc
->ciss_cfg
->supported_methods
& CISS_TRANSPORT_METHOD_SIMPLE
)) {
596 ciss_printf(sc
, "adapter does not support 'simple' transport layer\n");
599 sc
->ciss_cfg
->requested_method
= CISS_TRANSPORT_METHOD_SIMPLE
;
600 sc
->ciss_cfg
->command_physlimit
= 0;
601 sc
->ciss_cfg
->interrupt_coalesce_delay
= CISS_INTERRUPT_COALESCE_DELAY
;
602 sc
->ciss_cfg
->interrupt_coalesce_count
= CISS_INTERRUPT_COALESCE_COUNT
;
605 sc
->ciss_cfg
->host_driver
|= CISS_DRIVER_SCSI_PREFETCH
;
608 if (ciss_update_config(sc
)) {
609 ciss_printf(sc
, "adapter refuses to accept config update (IDBR 0x%x)\n",
610 CISS_TL_SIMPLE_READ(sc
, CISS_TL_SIMPLE_IDBR
));
613 if (!(sc
->ciss_cfg
->active_method
!= CISS_TRANSPORT_METHOD_SIMPLE
)) {
615 "adapter refuses to go into 'simple' transport mode (0x%x, 0x%x)\n",
616 sc
->ciss_cfg
->supported_methods
, sc
->ciss_cfg
->active_method
);
621 * Wait for the adapter to come ready.
623 if ((error
= ciss_wait_adapter(sc
)) != 0)
627 * Turn off interrupts before we go routing anything.
629 CISS_TL_SIMPLE_DISABLE_INTERRUPTS(sc
);
632 * Allocate and set up our interrupt.
634 sc
->ciss_irq_rid
= 0;
635 if ((sc
->ciss_irq_resource
=
636 bus_alloc_resource(sc
->ciss_dev
, SYS_RES_IRQ
, &sc
->ciss_irq_rid
, 0, ~0, 1,
637 RF_ACTIVE
| RF_SHAREABLE
)) == NULL
) {
638 ciss_printf(sc
, "can't allocate interrupt\n");
641 error
= bus_setup_intr(sc
->ciss_dev
, sc
->ciss_irq_resource
,
643 &sc
->ciss_intr
, NULL
);
645 ciss_printf(sc
, "can't set up interrupt\n");
650 * Allocate the parent bus DMA tag appropriate for our PCI
653 * Note that "simple" adapters can only address within a 32-bit
656 if (bus_dma_tag_create(NULL
, /* parent */
657 1, 0, /* alignment, boundary */
658 BUS_SPACE_MAXADDR
, /* lowaddr */
659 BUS_SPACE_MAXADDR
, /* highaddr */
660 NULL
, NULL
, /* filter, filterarg */
661 BUS_SPACE_MAXSIZE_32BIT
, /* maxsize */
662 CISS_COMMAND_SG_LENGTH
, /* nsegments */
663 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
664 BUS_DMA_ALLOCNOW
, /* flags */
665 &sc
->ciss_parent_dmat
)) {
666 ciss_printf(sc
, "can't allocate parent DMA tag\n");
671 * Create DMA tag for mapping buffers into adapter-addressable
674 if (bus_dma_tag_create(sc
->ciss_parent_dmat
, /* parent */
675 1, 0, /* alignment, boundary */
676 BUS_SPACE_MAXADDR
, /* lowaddr */
677 BUS_SPACE_MAXADDR
, /* highaddr */
678 NULL
, NULL
, /* filter, filterarg */
679 MAXBSIZE
, CISS_COMMAND_SG_LENGTH
, /* maxsize, nsegments */
680 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
682 &sc
->ciss_buffer_dmat
)) {
683 ciss_printf(sc
, "can't allocate buffer DMA tag\n");
689 /************************************************************************
690 * Wait for the adapter to come ready.
693 ciss_wait_adapter(struct ciss_softc
*sc
)
700 * Wait for the adapter to come ready.
702 if (!(sc
->ciss_cfg
->active_method
& CISS_TRANSPORT_METHOD_READY
)) {
703 ciss_printf(sc
, "waiting for adapter to come ready...\n");
704 for (i
= 0; !(sc
->ciss_cfg
->active_method
& CISS_TRANSPORT_METHOD_READY
); i
++) {
705 DELAY(1000000); /* one second */
707 ciss_printf(sc
, "timed out waiting for adapter to come ready\n");
715 /************************************************************************
716 * Flush the adapter cache.
719 ciss_flush_adapter(struct ciss_softc
*sc
)
721 struct ciss_request
*cr
;
722 struct ciss_bmic_flush_cache
*cbfc
;
723 int error
, command_status
;
731 * Build a BMIC request to flush the cache. We don't disable
732 * it, as we may be going to do more I/O (eg. we are emulating
733 * the Synchronise Cache command).
735 cbfc
= kmalloc(sizeof(*cbfc
), CISS_MALLOC_CLASS
, M_INTWAIT
| M_ZERO
);
736 if ((error
= ciss_get_bmic_request(sc
, &cr
, CISS_BMIC_FLUSH_CACHE
,
737 (void **)&cbfc
, sizeof(*cbfc
))) != 0)
741 * Submit the request and wait for it to complete.
743 if ((error
= ciss_synch_request(cr
, 60 * 1000)) != 0) {
744 ciss_printf(sc
, "error sending BMIC FLUSH_CACHE command (%d)\n", error
);
751 ciss_report_request(cr
, &command_status
, NULL
);
752 switch(command_status
) {
753 case CISS_CMD_STATUS_SUCCESS
:
756 ciss_printf(sc
, "error flushing cache (%s)\n",
757 ciss_name_command_status(command_status
));
764 kfree(cbfc
, CISS_MALLOC_CLASS
);
766 ciss_release_request(cr
);
770 /************************************************************************
771 * Allocate memory for the adapter command structures, initialise
772 * the request structures.
774 * Note that the entire set of commands are allocated in a single
778 ciss_init_requests(struct ciss_softc
*sc
)
780 struct ciss_request
*cr
;
786 * Calculate the number of request structures/commands we are
787 * going to provide for this adapter.
789 sc
->ciss_max_requests
= min(CISS_MAX_REQUESTS
, sc
->ciss_cfg
->max_outstanding_commands
);
792 ciss_printf(sc
, "using %d of %d available commands\n",
793 sc
->ciss_max_requests
, sc
->ciss_cfg
->max_outstanding_commands
);
796 * Create the DMA tag for commands.
798 if (bus_dma_tag_create(sc
->ciss_parent_dmat
, /* parent */
799 1, 0, /* alignment, boundary */
800 BUS_SPACE_MAXADDR_32BIT
, /* lowaddr */
801 BUS_SPACE_MAXADDR
, /* highaddr */
802 NULL
, NULL
, /* filter, filterarg */
803 CISS_COMMAND_ALLOC_SIZE
*
804 sc
->ciss_max_requests
, 1, /* maxsize, nsegments */
805 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
806 BUS_DMA_ALLOCNOW
, /* flags */
807 &sc
->ciss_command_dmat
)) {
808 ciss_printf(sc
, "can't allocate command DMA tag\n");
812 * Allocate memory and make it available for DMA.
814 if (bus_dmamem_alloc(sc
->ciss_command_dmat
, (void **)&sc
->ciss_command
,
815 BUS_DMA_NOWAIT
, &sc
->ciss_command_map
)) {
816 ciss_printf(sc
, "can't allocate command memory\n");
819 bus_dmamap_load(sc
->ciss_command_dmat
, sc
->ciss_command_map
, sc
->ciss_command
,
820 CISS_COMMAND_ALLOC_SIZE
* sc
->ciss_max_requests
,
821 ciss_command_map_helper
, sc
, 0);
822 bzero(sc
->ciss_command
, CISS_COMMAND_ALLOC_SIZE
* sc
->ciss_max_requests
);
825 * Set up the request and command structures, push requests onto
828 for (i
= 1; i
< sc
->ciss_max_requests
; i
++) {
829 cr
= &sc
->ciss_request
[i
];
832 bus_dmamap_create(sc
->ciss_buffer_dmat
, 0, &cr
->cr_datamap
);
833 ciss_enqueue_free(cr
);
839 ciss_command_map_helper(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
841 struct ciss_softc
*sc
= (struct ciss_softc
*)arg
;
843 sc
->ciss_command_phys
= segs
->ds_addr
;
846 /************************************************************************
847 * Identify the adapter, print some information about it.
850 ciss_identify_adapter(struct ciss_softc
*sc
)
852 struct ciss_request
*cr
;
853 int error
, command_status
;
860 * Get a request, allocate storage for the adapter data.
862 if ((error
= ciss_get_bmic_request(sc
, &cr
, CISS_BMIC_ID_CTLR
,
863 (void **)&sc
->ciss_id
,
864 sizeof(*sc
->ciss_id
))) != 0)
868 * Submit the request and wait for it to complete.
870 if ((error
= ciss_synch_request(cr
, 60 * 1000)) != 0) {
871 ciss_printf(sc
, "error sending BMIC ID_CTLR command (%d)\n", error
);
878 ciss_report_request(cr
, &command_status
, NULL
);
879 switch(command_status
) {
880 case CISS_CMD_STATUS_SUCCESS
: /* buffer right size */
882 case CISS_CMD_STATUS_DATA_UNDERRUN
:
883 case CISS_CMD_STATUS_DATA_OVERRUN
:
884 ciss_printf(sc
, "data over/underrun reading adapter information\n");
886 ciss_printf(sc
, "error reading adapter information (%s)\n",
887 ciss_name_command_status(command_status
));
892 /* sanity-check reply */
893 if (!sc
->ciss_id
->big_map_supported
) {
894 ciss_printf(sc
, "adapter does not support BIG_MAP\n");
900 /* XXX later revisions may not need this */
901 sc
->ciss_flags
|= CISS_FLAG_FAKE_SYNCH
;
904 /* XXX only really required for old 5300 adapters? */
905 sc
->ciss_flags
|= CISS_FLAG_BMIC_ABORT
;
907 /* print information */
909 #if 0 /* XXX proxy volumes??? */
910 ciss_printf(sc
, " %d logical drive%s configured\n",
911 sc
->ciss_id
->configured_logical_drives
,
912 (sc
->ciss_id
->configured_logical_drives
== 1) ? "" : "s");
914 ciss_printf(sc
, " firmware %4.4s\n", sc
->ciss_id
->running_firmware_revision
);
915 ciss_printf(sc
, " %d SCSI channels\n", sc
->ciss_id
->scsi_bus_count
);
917 ciss_printf(sc
, " signature '%.4s'\n", sc
->ciss_cfg
->signature
);
918 ciss_printf(sc
, " valence %d\n", sc
->ciss_cfg
->valence
);
919 ciss_printf(sc
, " supported I/O methods 0x%b\n",
920 sc
->ciss_cfg
->supported_methods
,
921 "\20\1READY\2simple\3performant\4MEMQ\n");
922 ciss_printf(sc
, " active I/O method 0x%b\n",
923 sc
->ciss_cfg
->active_method
, "\20\2simple\3performant\4MEMQ\n");
924 ciss_printf(sc
, " 4G page base 0x%08x\n",
925 sc
->ciss_cfg
->command_physlimit
);
926 ciss_printf(sc
, " interrupt coalesce delay %dus\n",
927 sc
->ciss_cfg
->interrupt_coalesce_delay
);
928 ciss_printf(sc
, " interrupt coalesce count %d\n",
929 sc
->ciss_cfg
->interrupt_coalesce_count
);
930 ciss_printf(sc
, " max outstanding commands %d\n",
931 sc
->ciss_cfg
->max_outstanding_commands
);
932 ciss_printf(sc
, " bus types 0x%b\n", sc
->ciss_cfg
->bus_types
,
933 "\20\1ultra2\2ultra3\10fibre1\11fibre2\n");
934 ciss_printf(sc
, " server name '%.16s'\n", sc
->ciss_cfg
->server_name
);
935 ciss_printf(sc
, " heartbeat 0x%x\n", sc
->ciss_cfg
->heartbeat
);
940 if (sc
->ciss_id
!= NULL
) {
941 kfree(sc
->ciss_id
, CISS_MALLOC_CLASS
);
946 ciss_release_request(cr
);
950 /************************************************************************
951 * Helper routine for generating a list of logical and physical luns.
953 static struct ciss_lun_report
*
954 ciss_report_luns(struct ciss_softc
*sc
, int opcode
, int nunits
)
956 struct ciss_request
*cr
;
957 struct ciss_command
*cc
;
958 struct ciss_report_cdb
*crc
;
959 struct ciss_lun_report
*cll
;
970 * Get a request, allocate storage for the address list.
972 if ((error
= ciss_get_request(sc
, &cr
)) != 0)
974 report_size
= sizeof(*cll
) + nunits
* sizeof(union ciss_device_address
);
975 cll
= kmalloc(report_size
, CISS_MALLOC_CLASS
, M_INTWAIT
| M_ZERO
);
978 * Build the Report Logical/Physical LUNs command.
980 cc
= CISS_FIND_COMMAND(cr
);
982 cr
->cr_length
= report_size
;
983 cr
->cr_flags
= CISS_REQ_DATAIN
;
985 cc
->header
.address
.physical
.mode
= CISS_HDR_ADDRESS_MODE_PERIPHERAL
;
986 cc
->header
.address
.physical
.bus
= 0;
987 cc
->header
.address
.physical
.target
= 0;
988 cc
->cdb
.cdb_length
= sizeof(*crc
);
989 cc
->cdb
.type
= CISS_CDB_TYPE_COMMAND
;
990 cc
->cdb
.attribute
= CISS_CDB_ATTRIBUTE_SIMPLE
;
991 cc
->cdb
.direction
= CISS_CDB_DIRECTION_READ
;
992 cc
->cdb
.timeout
= 30; /* XXX better suggestions? */
994 crc
= (struct ciss_report_cdb
*)&(cc
->cdb
.cdb
[0]);
995 bzero(crc
, sizeof(*crc
));
996 crc
->opcode
= opcode
;
997 crc
->length
= htonl(report_size
); /* big-endian field */
998 cll
->list_size
= htonl(report_size
- sizeof(*cll
)); /* big-endian field */
1001 * Submit the request and wait for it to complete. (timeout
1002 * here should be much greater than above)
1004 if ((error
= ciss_synch_request(cr
, 60 * 1000)) != 0) {
1005 ciss_printf(sc
, "error sending %d LUN command (%d)\n", opcode
, error
);
1010 * Check response. Note that data over/underrun is OK.
1012 ciss_report_request(cr
, &command_status
, NULL
);
1013 switch(command_status
) {
1014 case CISS_CMD_STATUS_SUCCESS
: /* buffer right size */
1015 case CISS_CMD_STATUS_DATA_UNDERRUN
: /* buffer too large, not bad */
1017 case CISS_CMD_STATUS_DATA_OVERRUN
:
1018 ciss_printf(sc
, "WARNING: more units than driver limit (%d)\n",
1022 ciss_printf(sc
, "error detecting logical drive configuration (%s)\n",
1023 ciss_name_command_status(command_status
));
1027 ciss_release_request(cr
);
1032 ciss_release_request(cr
);
1033 if (error
&& cll
!= NULL
) {
1034 kfree(cll
, CISS_MALLOC_CLASS
);
1040 /************************************************************************
1041 * Find logical drives on the adapter.
1044 ciss_init_logical(struct ciss_softc
*sc
)
1046 struct ciss_lun_report
*cll
;
1047 int error
= 0, i
, j
;
1052 cll
= ciss_report_luns(sc
, CISS_OPCODE_REPORT_LOGICAL_LUNS
,
1059 /* sanity-check reply */
1060 ndrives
= (ntohl(cll
->list_size
) / sizeof(union ciss_device_address
));
1061 if ((ndrives
< 0) || (ndrives
>= CISS_MAX_LOGICAL
)) {
1062 ciss_printf(sc
, "adapter claims to report absurd number of logical drives (%d > %d)\n",
1063 ndrives
, CISS_MAX_LOGICAL
);
1069 * Save logical drive information.
1072 ciss_printf(sc
, "%d logical drive%s\n",
1073 ndrives
, (ndrives
> 1 || ndrives
== 0) ? "s" : "");
1077 kmalloc(sc
->ciss_max_logical_bus
* sizeof(struct ciss_ldrive
*),
1078 CISS_MALLOC_CLASS
, M_INTWAIT
| M_ZERO
);
1080 for (i
= 0; i
<= sc
->ciss_max_logical_bus
; i
++) {
1081 sc
->ciss_logical
[i
] =
1082 kmalloc(CISS_MAX_LOGICAL
* sizeof(struct ciss_ldrive
),
1083 CISS_MALLOC_CLASS
, M_INTWAIT
| M_ZERO
);
1085 for (j
= 0; j
< CISS_MAX_LOGICAL
; j
++)
1086 sc
->ciss_logical
[i
][j
].cl_status
= CISS_LD_NONEXISTENT
;
1090 for (i
= 0; i
< CISS_MAX_LOGICAL
; i
++) {
1092 struct ciss_ldrive
*ld
;
1095 bus
= CISS_LUN_TO_BUS(cll
->lun
[i
].logical
.lun
);
1096 target
= CISS_LUN_TO_TARGET(cll
->lun
[i
].logical
.lun
);
1097 ld
= &sc
->ciss_logical
[bus
][target
];
1099 ld
->cl_address
= cll
->lun
[i
];
1100 ld
->cl_controller
= &sc
->ciss_controllers
[bus
];
1101 if (ciss_identify_logical(sc
, ld
) != 0)
1104 * If the drive has had media exchanged, we should bring it online.
1106 if (ld
->cl_lstatus
->media_exchanged
)
1107 ciss_accept_media(sc
, ld
);
1114 kfree(cll
, CISS_MALLOC_CLASS
);
1119 ciss_init_physical(struct ciss_softc
*sc
)
1121 struct ciss_lun_report
*cll
;
1131 cll
= ciss_report_luns(sc
, CISS_OPCODE_REPORT_PHYSICAL_LUNS
,
1138 nphys
= (ntohl(cll
->list_size
) / sizeof(union ciss_device_address
));
1141 ciss_printf(sc
, "%d physical device%s\n",
1142 nphys
, (nphys
> 1 || nphys
== 0) ? "s" : "");
1146 * Figure out the bus mapping.
1147 * Logical buses include both the local logical bus for local arrays and
1148 * proxy buses for remote arrays. Physical buses are numbered by the
1149 * controller and represent physical buses that hold physical devices.
1150 * We shift these bus numbers so that everything fits into a single flat
1151 * numbering space for CAM. Logical buses occupy the first 32 CAM bus
1152 * numbers, and the physical bus numbers are shifted to be above that.
1153 * This results in the various driver arrays being indexed as follows:
1155 * ciss_controllers[] - indexed by logical bus
1156 * ciss_cam_sim[] - indexed by both logical and physical, with physical
1157 * being shifted by 32.
1158 * ciss_logical[][] - indexed by logical bus
1159 * ciss_physical[][] - indexed by physical bus
1161 * XXX This is getting more and more hackish. CISS really doesn't play
1162 * well with a standard SCSI model; devices are addressed via magic
1163 * cookies, not via b/t/l addresses. Since there is no way to store
1164 * the cookie in the CAM device object, we have to keep these lookup
1165 * tables handy so that the devices can be found quickly at the cost
1166 * of wasting memory and having a convoluted lookup scheme. This
1167 * driver should probably be converted to block interface.
1170 * If the L2 and L3 SCSI addresses are 0, this signifies a proxy
1171 * controller. A proxy controller is another physical controller
1172 * behind the primary PCI controller. We need to know about this
1173 * so that BMIC commands can be properly targeted. There can be
1174 * proxy controllers attached to a single PCI controller, so
1175 * find the highest numbered one so the array can be properly
1178 sc
->ciss_max_logical_bus
= 1;
1179 for (i
= 0; i
< nphys
; i
++) {
1180 if (cll
->lun
[i
].physical
.extra_address
== 0) {
1181 bus
= cll
->lun
[i
].physical
.bus
;
1182 sc
->ciss_max_logical_bus
= max(sc
->ciss_max_logical_bus
, bus
) + 1;
1184 bus
= CISS_EXTRA_BUS2(cll
->lun
[i
].physical
.extra_address
);
1185 sc
->ciss_max_physical_bus
= max(sc
->ciss_max_physical_bus
, bus
);
1189 sc
->ciss_controllers
=
1190 kmalloc(sc
->ciss_max_logical_bus
* sizeof (union ciss_device_address
),
1191 CISS_MALLOC_CLASS
, M_INTWAIT
| M_ZERO
);
1193 /* setup a map of controller addresses */
1194 for (i
= 0; i
< nphys
; i
++) {
1195 if (cll
->lun
[i
].physical
.extra_address
== 0) {
1196 sc
->ciss_controllers
[cll
->lun
[i
].physical
.bus
] = cll
->lun
[i
];
1201 kmalloc(sc
->ciss_max_physical_bus
* sizeof(struct ciss_pdrive
*),
1202 CISS_MALLOC_CLASS
, M_INTWAIT
| M_ZERO
);
1204 for (i
= 0; i
< sc
->ciss_max_physical_bus
; i
++) {
1205 sc
->ciss_physical
[i
] =
1206 kmalloc(sizeof(struct ciss_pdrive
) * CISS_MAX_PHYSTGT
,
1207 CISS_MALLOC_CLASS
, M_INTWAIT
| M_ZERO
);
1210 ciss_filter_physical(sc
, cll
);
1214 kfree(cll
, CISS_MALLOC_CLASS
);
1220 ciss_filter_physical(struct ciss_softc
*sc
, struct ciss_lun_report
*cll
)
1226 nphys
= (ntohl(cll
->list_size
) / sizeof(union ciss_device_address
));
1227 for (i
= 0; i
< nphys
; i
++) {
1228 if (cll
->lun
[i
].physical
.extra_address
== 0)
1232 * Filter out devices that we don't want. Level 3 LUNs could
1233 * probably be supported, but the docs don't give enough of a
1236 * The mode field of the physical address is likely set to have
1237 * hard disks masked out. Honor it unless the user has overridden
1238 * us with the tunable. We also munge the inquiry data for these
1239 * disks so that they only show up as passthrough devices. Keeping
1240 * them visible in this fashion is useful for doing things like
1241 * flashing firmware.
1243 ea
= cll
->lun
[i
].physical
.extra_address
;
1244 if ((CISS_EXTRA_BUS3(ea
) != 0) || (CISS_EXTRA_TARGET3(ea
) != 0) ||
1245 (CISS_EXTRA_MODE2(ea
) == 0x3))
1247 if ((ciss_expose_hidden_physical
== 0) &&
1248 (cll
->lun
[i
].physical
.mode
== CISS_HDR_ADDRESS_MODE_MASK_PERIPHERAL
))
1252 * Note: CISS firmware numbers physical busses starting at '1', not
1253 * '0'. This numbering is internal to the firmware and is only
1254 * used as a hint here.
1256 bus
= CISS_EXTRA_BUS2(ea
) - 1;
1257 target
= CISS_EXTRA_TARGET2(ea
);
1258 sc
->ciss_physical
[bus
][target
].cp_address
= cll
->lun
[i
];
1259 sc
->ciss_physical
[bus
][target
].cp_online
= 1;
1266 ciss_inquiry_logical(struct ciss_softc
*sc
, struct ciss_ldrive
*ld
)
1268 struct ciss_request
*cr
;
1269 struct ciss_command
*cc
;
1270 struct scsi_inquiry
*inq
;
1276 bzero(&ld
->cl_geometry
, sizeof(ld
->cl_geometry
));
1278 if ((error
= ciss_get_request(sc
, &cr
)) != 0)
1281 cc
= CISS_FIND_COMMAND(cr
);
1282 cr
->cr_data
= &ld
->cl_geometry
;
1283 cr
->cr_length
= sizeof(ld
->cl_geometry
);
1284 cr
->cr_flags
= CISS_REQ_DATAIN
;
1286 cc
->header
.address
= ld
->cl_address
;
1287 cc
->cdb
.cdb_length
= 6;
1288 cc
->cdb
.type
= CISS_CDB_TYPE_COMMAND
;
1289 cc
->cdb
.attribute
= CISS_CDB_ATTRIBUTE_SIMPLE
;
1290 cc
->cdb
.direction
= CISS_CDB_DIRECTION_READ
;
1291 cc
->cdb
.timeout
= 30;
1293 inq
= (struct scsi_inquiry
*)&(cc
->cdb
.cdb
[0]);
1294 inq
->opcode
= INQUIRY
;
1295 inq
->byte2
= SI_EVPD
;
1296 inq
->page_code
= CISS_VPD_LOGICAL_DRIVE_GEOMETRY
;
1297 inq
->length
= sizeof(ld
->cl_geometry
);
1299 if ((error
= ciss_synch_request(cr
, 60 * 1000)) != 0) {
1300 ciss_printf(sc
, "error getting geometry (%d)\n", error
);
1304 ciss_report_request(cr
, &command_status
, NULL
);
1305 switch(command_status
) {
1306 case CISS_CMD_STATUS_SUCCESS
:
1307 case CISS_CMD_STATUS_DATA_UNDERRUN
:
1309 case CISS_CMD_STATUS_DATA_OVERRUN
:
1310 ciss_printf(sc
, "WARNING: Data overrun\n");
1313 ciss_printf(sc
, "Error detecting logical drive geometry (%s)\n",
1314 ciss_name_command_status(command_status
));
1320 ciss_release_request(cr
);
1323 /************************************************************************
1324 * Identify a logical drive, initialise state related to it.
1327 ciss_identify_logical(struct ciss_softc
*sc
, struct ciss_ldrive
*ld
)
1329 struct ciss_request
*cr
;
1330 struct ciss_command
*cc
;
1331 struct ciss_bmic_cdb
*cbc
;
1332 int error
, command_status
;
1339 * Build a BMIC request to fetch the drive ID.
1341 if ((error
= ciss_get_bmic_request(sc
, &cr
, CISS_BMIC_ID_LDRIVE
,
1342 (void **)&ld
->cl_ldrive
,
1343 sizeof(*ld
->cl_ldrive
))) != 0)
1345 cc
= CISS_FIND_COMMAND(cr
);
1346 cc
->header
.address
= *ld
->cl_controller
; /* target controller */
1347 cbc
= (struct ciss_bmic_cdb
*)&(cc
->cdb
.cdb
[0]);
1348 cbc
->log_drive
= CISS_LUN_TO_TARGET(ld
->cl_address
.logical
.lun
);
1351 * Submit the request and wait for it to complete.
1353 if ((error
= ciss_synch_request(cr
, 60 * 1000)) != 0) {
1354 ciss_printf(sc
, "error sending BMIC LDRIVE command (%d)\n", error
);
1361 ciss_report_request(cr
, &command_status
, NULL
);
1362 switch(command_status
) {
1363 case CISS_CMD_STATUS_SUCCESS
: /* buffer right size */
1365 case CISS_CMD_STATUS_DATA_UNDERRUN
:
1366 case CISS_CMD_STATUS_DATA_OVERRUN
:
1367 ciss_printf(sc
, "data over/underrun reading logical drive ID\n");
1369 ciss_printf(sc
, "error reading logical drive ID (%s)\n",
1370 ciss_name_command_status(command_status
));
1374 ciss_release_request(cr
);
1378 * Build a CISS BMIC command to get the logical drive status.
1380 if ((error
= ciss_get_ldrive_status(sc
, ld
)) != 0)
1384 * Get the logical drive geometry.
1386 if ((error
= ciss_inquiry_logical(sc
, ld
)) != 0)
1390 * Print the drive's basic characteristics.
1393 ciss_printf(sc
, "logical drive (b%dt%d): %s, %dMB ",
1394 CISS_LUN_TO_BUS(ld
->cl_address
.logical
.lun
),
1395 CISS_LUN_TO_TARGET(ld
->cl_address
.logical
.lun
),
1396 ciss_name_ldrive_org(ld
->cl_ldrive
->fault_tolerance
),
1397 ((ld
->cl_ldrive
->blocks_available
/ (1024 * 1024)) *
1398 ld
->cl_ldrive
->block_size
));
1400 ciss_print_ldrive(sc
, ld
);
1404 /* make the drive not-exist */
1405 ld
->cl_status
= CISS_LD_NONEXISTENT
;
1406 if (ld
->cl_ldrive
!= NULL
) {
1407 kfree(ld
->cl_ldrive
, CISS_MALLOC_CLASS
);
1408 ld
->cl_ldrive
= NULL
;
1410 if (ld
->cl_lstatus
!= NULL
) {
1411 kfree(ld
->cl_lstatus
, CISS_MALLOC_CLASS
);
1412 ld
->cl_lstatus
= NULL
;
1416 ciss_release_request(cr
);
1421 /************************************************************************
1422 * Get status for a logical drive.
1424 * XXX should we also do this in response to Test Unit Ready?
1427 ciss_get_ldrive_status(struct ciss_softc
*sc
, struct ciss_ldrive
*ld
)
1429 struct ciss_request
*cr
;
1430 struct ciss_command
*cc
;
1431 struct ciss_bmic_cdb
*cbc
;
1432 int error
, command_status
;
1435 * Build a CISS BMIC command to get the logical drive status.
1437 if ((error
= ciss_get_bmic_request(sc
, &cr
, CISS_BMIC_ID_LSTATUS
,
1438 (void **)&ld
->cl_lstatus
,
1439 sizeof(*ld
->cl_lstatus
))) != 0)
1441 cc
= CISS_FIND_COMMAND(cr
);
1442 cc
->header
.address
= *ld
->cl_controller
; /* target controller */
1443 cbc
= (struct ciss_bmic_cdb
*)&(cc
->cdb
.cdb
[0]);
1444 cbc
->log_drive
= CISS_LUN_TO_TARGET(ld
->cl_address
.logical
.lun
);
1447 * Submit the request and wait for it to complete.
1449 if ((error
= ciss_synch_request(cr
, 60 * 1000)) != 0) {
1450 ciss_printf(sc
, "error sending BMIC LSTATUS command (%d)\n", error
);
1457 ciss_report_request(cr
, &command_status
, NULL
);
1458 switch(command_status
) {
1459 case CISS_CMD_STATUS_SUCCESS
: /* buffer right size */
1461 case CISS_CMD_STATUS_DATA_UNDERRUN
:
1462 case CISS_CMD_STATUS_DATA_OVERRUN
:
1463 ciss_printf(sc
, "data over/underrun reading logical drive status\n");
1465 ciss_printf(sc
, "error reading logical drive status (%s)\n",
1466 ciss_name_command_status(command_status
));
1472 * Set the drive's summary status based on the returned status.
1474 * XXX testing shows that a failed JBOD drive comes back at next
1475 * boot in "queued for expansion" mode. WTF?
1477 ld
->cl_status
= ciss_decode_ldrive_status(ld
->cl_lstatus
->status
);
1481 ciss_release_request(cr
);
1485 /************************************************************************
1486 * Notify the adapter of a config update.
1489 ciss_update_config(struct ciss_softc
*sc
)
1495 CISS_TL_SIMPLE_WRITE(sc
, CISS_TL_SIMPLE_IDBR
, CISS_TL_SIMPLE_IDBR_CFG_TABLE
);
1496 for (i
= 0; i
< 1000; i
++) {
1497 if (!(CISS_TL_SIMPLE_READ(sc
, CISS_TL_SIMPLE_IDBR
) &
1498 CISS_TL_SIMPLE_IDBR_CFG_TABLE
)) {
1506 /************************************************************************
1507 * Accept new media into a logical drive.
1509 * XXX The drive has previously been offline; it would be good if we
1510 * could make sure it's not open right now.
1513 ciss_accept_media(struct ciss_softc
*sc
, struct ciss_ldrive
*ld
)
1515 struct ciss_request
*cr
;
1516 struct ciss_command
*cc
;
1517 struct ciss_bmic_cdb
*cbc
;
1519 int error
= 0, ldrive
;
1521 ldrive
= CISS_LUN_TO_TARGET(ld
->cl_address
.logical
.lun
);
1523 debug(0, "bringing logical drive %d back online", ldrive
);
1526 * Build a CISS BMIC command to bring the drive back online.
1528 if ((error
= ciss_get_bmic_request(sc
, &cr
, CISS_BMIC_ACCEPT_MEDIA
,
1531 cc
= CISS_FIND_COMMAND(cr
);
1532 cc
->header
.address
= *ld
->cl_controller
; /* target controller */
1533 cbc
= (struct ciss_bmic_cdb
*)&(cc
->cdb
.cdb
[0]);
1534 cbc
->log_drive
= ldrive
;
1537 * Submit the request and wait for it to complete.
1539 if ((error
= ciss_synch_request(cr
, 60 * 1000)) != 0) {
1540 ciss_printf(sc
, "error sending BMIC ACCEPT MEDIA command (%d)\n", error
);
1547 ciss_report_request(cr
, &command_status
, NULL
);
1548 switch(command_status
) {
1549 case CISS_CMD_STATUS_SUCCESS
: /* all OK */
1550 /* we should get a logical drive status changed event here */
1553 ciss_printf(cr
->cr_sc
, "error accepting media into failed logical drive (%s)\n",
1554 ciss_name_command_status(command_status
));
1560 ciss_release_request(cr
);
1564 /************************************************************************
1565 * Release adapter resources.
1568 ciss_free(struct ciss_softc
*sc
)
1570 struct ciss_request
*cr
;
1575 /* we're going away */
1576 sc
->ciss_flags
|= CISS_FLAG_ABORTING
;
1578 /* terminate the periodic heartbeat routine */
1579 callout_stop(&sc
->ciss_periodic
);
1581 /* cancel the Event Notify chain */
1582 ciss_notify_abort(sc
);
1584 ciss_kill_notify_thread(sc
);
1586 /* remove the control device */
1587 if (sc
->ciss_dev_t
!= NULL
)
1588 destroy_dev(sc
->ciss_dev_t
);
1590 /* free the controller data */
1591 if (sc
->ciss_id
!= NULL
)
1592 kfree(sc
->ciss_id
, CISS_MALLOC_CLASS
);
1594 /* release I/O resources */
1595 if (sc
->ciss_regs_resource
!= NULL
)
1596 bus_release_resource(sc
->ciss_dev
, SYS_RES_MEMORY
,
1597 sc
->ciss_regs_rid
, sc
->ciss_regs_resource
);
1598 if (sc
->ciss_cfg_resource
!= NULL
)
1599 bus_release_resource(sc
->ciss_dev
, SYS_RES_MEMORY
,
1600 sc
->ciss_cfg_rid
, sc
->ciss_cfg_resource
);
1601 if (sc
->ciss_intr
!= NULL
)
1602 bus_teardown_intr(sc
->ciss_dev
, sc
->ciss_irq_resource
, sc
->ciss_intr
);
1603 if (sc
->ciss_irq_resource
!= NULL
)
1604 bus_release_resource(sc
->ciss_dev
, SYS_RES_IRQ
,
1605 sc
->ciss_irq_rid
, sc
->ciss_irq_resource
);
1607 /* destroy DMA tags */
1608 if (sc
->ciss_parent_dmat
)
1609 bus_dma_tag_destroy(sc
->ciss_parent_dmat
);
1611 while ((cr
= ciss_dequeue_free(sc
)) != NULL
)
1612 bus_dmamap_destroy(sc
->ciss_buffer_dmat
, cr
->cr_datamap
);
1613 if (sc
->ciss_buffer_dmat
)
1614 bus_dma_tag_destroy(sc
->ciss_buffer_dmat
);
1616 /* destroy command memory and DMA tag */
1617 if (sc
->ciss_command
!= NULL
) {
1618 bus_dmamap_unload(sc
->ciss_command_dmat
, sc
->ciss_command_map
);
1619 bus_dmamem_free(sc
->ciss_command_dmat
, sc
->ciss_command
, sc
->ciss_command_map
);
1621 if (sc
->ciss_command_dmat
)
1622 bus_dma_tag_destroy(sc
->ciss_command_dmat
);
1624 /* disconnect from CAM */
1625 if (sc
->ciss_cam_sim
) {
1626 for (i
= 0; i
< sc
->ciss_max_logical_bus
; i
++) {
1627 if (sc
->ciss_cam_sim
[i
]) {
1628 xpt_bus_deregister(cam_sim_path(sc
->ciss_cam_sim
[i
]));
1629 cam_sim_free(sc
->ciss_cam_sim
[i
]);
1632 for (i
= CISS_PHYSICAL_BASE
; i
< sc
->ciss_max_physical_bus
+
1633 CISS_PHYSICAL_BASE
; i
++) {
1634 if (sc
->ciss_cam_sim
[i
]) {
1635 xpt_bus_deregister(cam_sim_path(sc
->ciss_cam_sim
[i
]));
1636 cam_sim_free(sc
->ciss_cam_sim
[i
]);
1639 kfree(sc
->ciss_cam_sim
, CISS_MALLOC_CLASS
);
1641 if (sc
->ciss_cam_devq
)
1642 cam_simq_release(sc
->ciss_cam_devq
);
1644 if (sc
->ciss_logical
) {
1645 for (i
= 0; i
< sc
->ciss_max_logical_bus
; i
++)
1646 kfree(sc
->ciss_logical
[i
], CISS_MALLOC_CLASS
);
1647 kfree(sc
->ciss_logical
, CISS_MALLOC_CLASS
);
1650 if (sc
->ciss_physical
) {
1651 for (i
= 0; i
< sc
->ciss_max_physical_bus
; i
++)
1652 kfree(sc
->ciss_physical
[i
], CISS_MALLOC_CLASS
);
1653 kfree(sc
->ciss_physical
, CISS_MALLOC_CLASS
);
1656 if (sc
->ciss_controllers
)
1657 kfree(sc
->ciss_controllers
, CISS_MALLOC_CLASS
);
1660 /************************************************************************
1661 * Give a command to the adapter.
1663 * Note that this uses the simple transport layer directly. If we
1664 * want to add support for other layers, we'll need a switch of some
1667 * Note that the simple transport layer has no way of refusing a
1668 * command; we only have as many request structures as the adapter
1669 * supports commands, so we don't have to check (this presumes that
1670 * the adapter can handle commands as fast as we throw them at it).
1673 ciss_start(struct ciss_request
*cr
)
1675 struct ciss_command
*cc
; /* XXX debugging only */
1678 cc
= CISS_FIND_COMMAND(cr
);
1679 debug(2, "post command %d tag %d ", cr
->cr_tag
, cc
->header
.host_tag
);
1682 * Map the request's data.
1684 if ((error
= ciss_map_request(cr
)))
1688 ciss_print_request(cr
);
1694 /************************************************************************
1695 * Fetch completed request(s) from the adapter, queue them for
1696 * completion handling.
1698 * Note that this uses the simple transport layer directly. If we
1699 * want to add support for other layers, we'll need a switch of some
1702 * Note that the simple transport mechanism does not require any
1703 * reentrancy protection; the OPQ read is atomic. If there is a
1704 * chance of a race with something else that might move the request
1705 * off the busy list, then we will have to lock against that
1706 * (eg. timeouts, etc.)
1709 ciss_done(struct ciss_softc
*sc
)
1711 struct ciss_request
*cr
;
1712 struct ciss_command
*cc
;
1713 u_int32_t tag
, index
;
1719 * Loop quickly taking requests from the adapter and moving them
1720 * from the busy queue to the completed queue.
1725 /* see if the OPQ contains anything */
1726 if (!CISS_TL_SIMPLE_OPQ_INTERRUPT(sc
))
1729 tag
= CISS_TL_SIMPLE_FETCH_CMD(sc
);
1730 if (tag
== CISS_TL_SIMPLE_OPQ_EMPTY
)
1733 debug(2, "completed command %d%s", index
,
1734 (tag
& CISS_HDR_HOST_TAG_ERROR
) ? " with error" : "");
1735 if (index
>= sc
->ciss_max_requests
) {
1736 ciss_printf(sc
, "completed invalid request %d (0x%x)\n", index
, tag
);
1739 cr
= &(sc
->ciss_request
[index
]);
1740 cc
= CISS_FIND_COMMAND(cr
);
1741 cc
->header
.host_tag
= tag
; /* not updated by adapter */
1742 if (ciss_remove_busy(cr
)) {
1743 /* assume this is garbage out of the adapter */
1744 ciss_printf(sc
, "completed nonbusy request %d\n", index
);
1746 ciss_enqueue_complete(cr
);
1752 * Invoke completion processing. If we can defer this out of
1753 * interrupt context, that'd be good.
1759 /************************************************************************
1760 * Take an interrupt from the adapter.
1763 ciss_intr(void *arg
)
1765 struct ciss_softc
*sc
= (struct ciss_softc
*)arg
;
1768 * The only interrupt we recognise indicates that there are
1769 * entries in the outbound post queue.
1774 /************************************************************************
1775 * Process completed requests.
1777 * Requests can be completed in three fashions:
1779 * - by invoking a callback function (cr_complete is non-null)
1780 * - by waking up a sleeper (cr_flags has CISS_REQ_SLEEP set)
1781 * - by clearing the CISS_REQ_POLL flag in interrupt/timeout context
1784 ciss_complete(struct ciss_softc
*sc
)
1786 struct ciss_request
*cr
;
1791 * Loop taking requests off the completed queue and performing
1792 * completion processing on them.
1795 if ((cr
= ciss_dequeue_complete(sc
)) == NULL
)
1797 ciss_unmap_request(cr
);
1800 * If the request has a callback, invoke it.
1802 if (cr
->cr_complete
!= NULL
) {
1803 cr
->cr_complete(cr
);
1808 * If someone is sleeping on this request, wake them up.
1810 if (cr
->cr_flags
& CISS_REQ_SLEEP
) {
1811 cr
->cr_flags
&= ~CISS_REQ_SLEEP
;
1817 * If someone is polling this request for completion, signal.
1819 if (cr
->cr_flags
& CISS_REQ_POLL
) {
1820 cr
->cr_flags
&= ~CISS_REQ_POLL
;
1825 * Give up and throw the request back on the free queue. This
1826 * should never happen; resources will probably be lost.
1828 ciss_printf(sc
, "WARNING: completed command with no submitter\n");
1829 ciss_enqueue_free(cr
);
1833 /************************************************************************
1834 * Report on the completion status of a request, and pass back SCSI
1835 * and command status values.
1838 ciss_report_request(struct ciss_request
*cr
, int *command_status
, int *scsi_status
)
1840 struct ciss_command
*cc
;
1841 struct ciss_error_info
*ce
;
1845 cc
= CISS_FIND_COMMAND(cr
);
1846 ce
= (struct ciss_error_info
*)&(cc
->sg
[0]);
1849 * We don't consider data under/overrun an error for the Report
1850 * Logical/Physical LUNs commands.
1852 if ((cc
->header
.host_tag
& CISS_HDR_HOST_TAG_ERROR
) &&
1853 ((ce
->command_status
== CISS_CMD_STATUS_DATA_OVERRUN
) ||
1854 (ce
->command_status
== CISS_CMD_STATUS_DATA_UNDERRUN
)) &&
1855 ((cc
->cdb
.cdb
[0] == CISS_OPCODE_REPORT_LOGICAL_LUNS
) ||
1856 (cc
->cdb
.cdb
[0] == CISS_OPCODE_REPORT_PHYSICAL_LUNS
) ||
1857 (cc
->cdb
.cdb
[0] == INQUIRY
))) {
1858 cc
->header
.host_tag
&= ~CISS_HDR_HOST_TAG_ERROR
;
1859 debug(2, "ignoring irrelevant under/overrun error");
1863 * Check the command's error bit, if clear, there's no status and
1866 if (!(cc
->header
.host_tag
& CISS_HDR_HOST_TAG_ERROR
)) {
1867 if (scsi_status
!= NULL
)
1868 *scsi_status
= SCSI_STATUS_OK
;
1869 if (command_status
!= NULL
)
1870 *command_status
= CISS_CMD_STATUS_SUCCESS
;
1873 if (command_status
!= NULL
)
1874 *command_status
= ce
->command_status
;
1875 if (scsi_status
!= NULL
) {
1876 if (ce
->command_status
== CISS_CMD_STATUS_TARGET_STATUS
) {
1877 *scsi_status
= ce
->scsi_status
;
1883 ciss_printf(cr
->cr_sc
, "command status 0x%x (%s) scsi status 0x%x\n",
1884 ce
->command_status
, ciss_name_command_status(ce
->command_status
),
1886 if (ce
->command_status
== CISS_CMD_STATUS_INVALID_COMMAND
) {
1887 ciss_printf(cr
->cr_sc
, "invalid command, offense size %d at %d, value 0x%x\n",
1888 ce
->additional_error_info
.invalid_command
.offense_size
,
1889 ce
->additional_error_info
.invalid_command
.offense_offset
,
1890 ce
->additional_error_info
.invalid_command
.offense_value
);
1894 ciss_print_request(cr
);
1899 /************************************************************************
1900 * Issue a request and don't return until it's completed.
1902 * Depending on adapter status, we may poll or sleep waiting for
1906 ciss_synch_request(struct ciss_request
*cr
, int timeout
)
1908 if (cr
->cr_sc
->ciss_flags
& CISS_FLAG_RUNNING
) {
1909 return(ciss_wait_request(cr
, timeout
));
1911 return(ciss_poll_request(cr
, timeout
));
1915 /************************************************************************
1916 * Issue a request and poll for completion.
1918 * Timeout in milliseconds.
1921 ciss_poll_request(struct ciss_request
*cr
, int timeout
)
1927 cr
->cr_flags
|= CISS_REQ_POLL
;
1928 if ((error
= ciss_start(cr
)) != 0)
1932 ciss_done(cr
->cr_sc
);
1933 if (!(cr
->cr_flags
& CISS_REQ_POLL
))
1936 } while (timeout
-- >= 0);
1937 return(EWOULDBLOCK
);
1940 /************************************************************************
1941 * Issue a request and sleep waiting for completion.
1943 * Timeout in milliseconds. Note that a spurious wakeup will reset
1947 ciss_wait_request(struct ciss_request
*cr
, int timeout
)
1953 cr
->cr_flags
|= CISS_REQ_SLEEP
;
1954 if ((error
= ciss_start(cr
)) != 0)
1958 while ((cr
->cr_flags
& CISS_REQ_SLEEP
) && (error
!= EWOULDBLOCK
)) {
1959 error
= tsleep(cr
, 0, "cissREQ", (timeout
* hz
) / 1000);
1966 /************************************************************************
1967 * Abort a request. Note that a potential exists here to race the
1968 * request being completed; the caller must deal with this.
1971 ciss_abort_request(struct ciss_request
*ar
)
1973 struct ciss_request
*cr
;
1974 struct ciss_command
*cc
;
1975 struct ciss_message_cdb
*cmc
;
1981 if ((error
= ciss_get_request(ar
->cr_sc
, &cr
)) != 0)
1984 /* build the abort command */
1985 cc
= CISS_FIND_COMMAND(cr
);
1986 cc
->header
.address
.mode
.mode
= CISS_HDR_ADDRESS_MODE_PERIPHERAL
; /* addressing? */
1987 cc
->header
.address
.physical
.target
= 0;
1988 cc
->header
.address
.physical
.bus
= 0;
1989 cc
->cdb
.cdb_length
= sizeof(*cmc
);
1990 cc
->cdb
.type
= CISS_CDB_TYPE_MESSAGE
;
1991 cc
->cdb
.attribute
= CISS_CDB_ATTRIBUTE_SIMPLE
;
1992 cc
->cdb
.direction
= CISS_CDB_DIRECTION_NONE
;
1993 cc
->cdb
.timeout
= 30;
1995 cmc
= (struct ciss_message_cdb
*)&(cc
->cdb
.cdb
[0]);
1996 cmc
->opcode
= CISS_OPCODE_MESSAGE_ABORT
;
1997 cmc
->type
= CISS_MESSAGE_ABORT_TASK
;
1998 cmc
->abort_tag
= ar
->cr_tag
; /* endianness?? */
2001 * Send the request and wait for a response. If we believe we
2002 * aborted the request OK, clear the flag that indicates it's
2005 error
= ciss_synch_request(cr
, 35 * 1000);
2007 error
= ciss_report_request(cr
, NULL
, NULL
);
2008 ciss_release_request(cr
);
2015 /************************************************************************
2016 * Fetch and initialise a request
2019 ciss_get_request(struct ciss_softc
*sc
, struct ciss_request
**crp
)
2021 struct ciss_request
*cr
;
2026 * Get a request and clean it up.
2028 if ((cr
= ciss_dequeue_free(sc
)) == NULL
)
2033 cr
->cr_complete
= NULL
;
2034 cr
->cr_private
= NULL
;
2036 ciss_preen_command(cr
);
2042 ciss_preen_command(struct ciss_request
*cr
)
2044 struct ciss_command
*cc
;
2048 * Clean up the command structure.
2050 * Note that we set up the error_info structure here, since the
2051 * length can be overwritten by any command.
2053 cc
= CISS_FIND_COMMAND(cr
);
2054 cc
->header
.sg_in_list
= 0; /* kinda inefficient this way */
2055 cc
->header
.sg_total
= 0;
2056 cc
->header
.host_tag
= cr
->cr_tag
<< 2;
2057 cc
->header
.host_tag_zeroes
= 0;
2058 cmdphys
= CISS_FIND_COMMANDPHYS(cr
);
2059 cc
->error_info
.error_info_address
= cmdphys
+ sizeof(struct ciss_command
);
2060 cc
->error_info
.error_info_length
= CISS_COMMAND_ALLOC_SIZE
- sizeof(struct ciss_command
);
2063 /************************************************************************
2064 * Release a request to the free list.
2067 ciss_release_request(struct ciss_request
*cr
)
2069 struct ciss_softc
*sc
;
2075 /* release the request to the free queue */
2076 ciss_requeue_free(cr
);
2079 /************************************************************************
2080 * Allocate a request that will be used to send a BMIC command. Do some
2081 * of the common setup here to avoid duplicating it everywhere else.
2084 ciss_get_bmic_request(struct ciss_softc
*sc
, struct ciss_request
**crp
,
2085 int opcode
, void **bufp
, size_t bufsize
)
2087 struct ciss_request
*cr
;
2088 struct ciss_command
*cc
;
2089 struct ciss_bmic_cdb
*cbc
;
2102 if ((error
= ciss_get_request(sc
, &cr
)) != 0)
2106 * Allocate data storage if requested, determine the data direction.
2109 if ((bufsize
> 0) && (bufp
!= NULL
)) {
2110 if (*bufp
== NULL
) {
2111 buf
= kmalloc(bufsize
, CISS_MALLOC_CLASS
, M_INTWAIT
| M_ZERO
);
2114 dataout
= 1; /* we are given a buffer, so we are writing */
2119 * Build a CISS BMIC command to get the logical drive ID.
2122 cr
->cr_length
= bufsize
;
2124 cr
->cr_flags
= CISS_REQ_DATAIN
;
2126 cc
= CISS_FIND_COMMAND(cr
);
2127 cc
->header
.address
.physical
.mode
= CISS_HDR_ADDRESS_MODE_PERIPHERAL
;
2128 cc
->header
.address
.physical
.bus
= 0;
2129 cc
->header
.address
.physical
.target
= 0;
2130 cc
->cdb
.cdb_length
= sizeof(*cbc
);
2131 cc
->cdb
.type
= CISS_CDB_TYPE_COMMAND
;
2132 cc
->cdb
.attribute
= CISS_CDB_ATTRIBUTE_SIMPLE
;
2133 cc
->cdb
.direction
= dataout
? CISS_CDB_DIRECTION_WRITE
: CISS_CDB_DIRECTION_READ
;
2134 cc
->cdb
.timeout
= 0;
2136 cbc
= (struct ciss_bmic_cdb
*)&(cc
->cdb
.cdb
[0]);
2137 bzero(cbc
, sizeof(*cbc
));
2138 cbc
->opcode
= dataout
? CISS_ARRAY_CONTROLLER_WRITE
: CISS_ARRAY_CONTROLLER_READ
;
2139 cbc
->bmic_opcode
= opcode
;
2140 cbc
->size
= htons((u_int16_t
)bufsize
);
2145 ciss_release_request(cr
);
2146 if ((bufp
!= NULL
) && (*bufp
== NULL
) && (buf
!= NULL
))
2147 kfree(buf
, CISS_MALLOC_CLASS
);
2150 if ((bufp
!= NULL
) && (*bufp
== NULL
) && (buf
!= NULL
))
2156 /************************************************************************
2157 * Handle a command passed in from userspace.
2160 ciss_user_command(struct ciss_softc
*sc
, IOCTL_Command_struct
*ioc
)
2162 struct ciss_request
*cr
;
2163 struct ciss_command
*cc
;
2164 struct ciss_error_info
*ce
;
2174 if ((error
= ciss_get_request(sc
, &cr
)) != 0)
2176 cc
= CISS_FIND_COMMAND(cr
);
2179 * Allocate an in-kernel databuffer if required, copy in user data.
2181 cr
->cr_length
= ioc
->buf_size
;
2182 if (ioc
->buf_size
> 0) {
2183 cr
->cr_data
= kmalloc(ioc
->buf_size
, CISS_MALLOC_CLASS
, M_WAITOK
);
2184 if ((error
= copyin(ioc
->buf
, cr
->cr_data
, ioc
->buf_size
))) {
2185 debug(0, "copyin: bad data buffer %p/%d", ioc
->buf
, ioc
->buf_size
);
2191 * Build the request based on the user command.
2193 bcopy(&ioc
->LUN_info
, &cc
->header
.address
, sizeof(cc
->header
.address
));
2194 bcopy(&ioc
->Request
, &cc
->cdb
, sizeof(cc
->cdb
));
2196 /* XXX anything else to populate here? */
2201 if ((error
= ciss_synch_request(cr
, 60 * 1000))) {
2202 debug(0, "request failed - %d", error
);
2207 * Check to see if the command succeeded.
2209 ce
= (struct ciss_error_info
*)&(cc
->sg
[0]);
2210 if ((cc
->header
.host_tag
& CISS_HDR_HOST_TAG_ERROR
) == 0)
2211 bzero(ce
, sizeof(*ce
));
2214 * Copy the results back to the user.
2216 bcopy(ce
, &ioc
->error_info
, sizeof(*ce
));
2217 if ((ioc
->buf_size
> 0) &&
2218 (error
= copyout(cr
->cr_data
, ioc
->buf
, ioc
->buf_size
))) {
2219 debug(0, "copyout: bad data buffer %p/%d", ioc
->buf
, ioc
->buf_size
);
2227 if ((cr
!= NULL
) && (cr
->cr_data
!= NULL
))
2228 kfree(cr
->cr_data
, CISS_MALLOC_CLASS
);
2230 ciss_release_request(cr
);
2234 /************************************************************************
2235 * Map a request into bus-visible space, initialise the scatter/gather
2239 ciss_map_request(struct ciss_request
*cr
)
2241 struct ciss_softc
*sc
;
2248 /* check that mapping is necessary */
2249 if (cr
->cr_flags
& CISS_REQ_MAPPED
)
2252 cr
->cr_flags
|= CISS_REQ_MAPPED
;
2254 bus_dmamap_sync(sc
->ciss_command_dmat
, sc
->ciss_command_map
,
2255 BUS_DMASYNC_PREWRITE
);
2257 if (cr
->cr_data
!= NULL
) {
2258 error
= bus_dmamap_load(sc
->ciss_buffer_dmat
, cr
->cr_datamap
,
2259 cr
->cr_data
, cr
->cr_length
,
2260 ciss_request_map_helper
, cr
, 0);
2265 * Post the command to the adapter.
2267 ciss_enqueue_busy(cr
);
2268 CISS_TL_SIMPLE_POST_CMD(cr
->cr_sc
, CISS_FIND_COMMANDPHYS(cr
));
2275 ciss_request_map_helper(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
2277 struct ciss_command
*cc
;
2278 struct ciss_request
*cr
;
2279 struct ciss_softc
*sc
;
2284 cr
= (struct ciss_request
*)arg
;
2286 cc
= CISS_FIND_COMMAND(cr
);
2288 for (i
= 0; i
< nseg
; i
++) {
2289 cc
->sg
[i
].address
= segs
[i
].ds_addr
;
2290 cc
->sg
[i
].length
= segs
[i
].ds_len
;
2291 cc
->sg
[i
].extension
= 0;
2293 /* we leave the s/g table entirely within the command */
2294 cc
->header
.sg_in_list
= nseg
;
2295 cc
->header
.sg_total
= nseg
;
2297 if (cr
->cr_flags
& CISS_REQ_DATAIN
)
2298 bus_dmamap_sync(sc
->ciss_buffer_dmat
, cr
->cr_datamap
, BUS_DMASYNC_PREREAD
);
2299 if (cr
->cr_flags
& CISS_REQ_DATAOUT
)
2300 bus_dmamap_sync(sc
->ciss_buffer_dmat
, cr
->cr_datamap
, BUS_DMASYNC_PREWRITE
);
2303 * Post the command to the adapter.
2305 ciss_enqueue_busy(cr
);
2306 CISS_TL_SIMPLE_POST_CMD(cr
->cr_sc
, CISS_FIND_COMMANDPHYS(cr
));
2309 /************************************************************************
2310 * Unmap a request from bus-visible space.
2313 ciss_unmap_request(struct ciss_request
*cr
)
2315 struct ciss_softc
*sc
;
2321 /* check that unmapping is necessary */
2322 if ((cr
->cr_flags
& CISS_REQ_MAPPED
) == 0)
2325 bus_dmamap_sync(sc
->ciss_command_dmat
, sc
->ciss_command_map
,
2326 BUS_DMASYNC_POSTWRITE
);
2328 if (cr
->cr_data
== NULL
)
2331 if (cr
->cr_flags
& CISS_REQ_DATAIN
)
2332 bus_dmamap_sync(sc
->ciss_buffer_dmat
, cr
->cr_datamap
, BUS_DMASYNC_POSTREAD
);
2333 if (cr
->cr_flags
& CISS_REQ_DATAOUT
)
2334 bus_dmamap_sync(sc
->ciss_buffer_dmat
, cr
->cr_datamap
, BUS_DMASYNC_POSTWRITE
);
2336 bus_dmamap_unload(sc
->ciss_buffer_dmat
, cr
->cr_datamap
);
2338 cr
->cr_flags
&= ~CISS_REQ_MAPPED
;
2341 /************************************************************************
2342 * Attach the driver to CAM.
2344 * We put all the logical drives on a single SCSI bus.
2347 ciss_cam_init(struct ciss_softc
*sc
)
2354 * Allocate a devq. We can reuse this for the masked physical
2355 * devices if we decide to export these as well.
2357 if ((sc
->ciss_cam_devq
= cam_simq_alloc(sc
->ciss_max_requests
)) == NULL
) {
2358 ciss_printf(sc
, "can't allocate CAM SIM queue\n");
2365 * This naturally wastes a bit of memory. The alternative is to allocate
2366 * and register each bus as it is found, and then track them on a linked
2367 * list. Unfortunately, the driver has a few places where it needs to
2368 * look up the SIM based solely on bus number, and it's unclear whether
2369 * a list traversal would work for these situations.
2371 maxbus
= max(sc
->ciss_max_logical_bus
, sc
->ciss_max_physical_bus
+
2372 CISS_PHYSICAL_BASE
);
2373 sc
->ciss_cam_sim
= kmalloc(maxbus
* sizeof(struct cam_sim
*),
2374 CISS_MALLOC_CLASS
, M_INTWAIT
| M_ZERO
);
2376 for (i
= 0; i
< sc
->ciss_max_logical_bus
; i
++) {
2377 if ((sc
->ciss_cam_sim
[i
] = cam_sim_alloc(ciss_cam_action
, ciss_cam_poll
,
2379 device_get_unit(sc
->ciss_dev
),
2381 sc
->ciss_max_requests
- 2,
2382 sc
->ciss_cam_devq
)) == NULL
) {
2383 ciss_printf(sc
, "can't allocate CAM SIM for controller %d\n", i
);
2388 * Register bus with this SIM.
2390 if (i
== 0 || sc
->ciss_controllers
[i
].physical
.bus
!= 0) {
2391 if (xpt_bus_register(sc
->ciss_cam_sim
[i
], i
) != 0) {
2392 ciss_printf(sc
, "can't register SCSI bus %d\n", i
);
2398 for (i
= CISS_PHYSICAL_BASE
; i
< sc
->ciss_max_physical_bus
+
2399 CISS_PHYSICAL_BASE
; i
++) {
2400 if ((sc
->ciss_cam_sim
[i
] = cam_sim_alloc(ciss_cam_action
, ciss_cam_poll
,
2402 device_get_unit(sc
->ciss_dev
),
2404 sc
->ciss_max_requests
- 2,
2405 sc
->ciss_cam_devq
)) == NULL
) {
2406 ciss_printf(sc
, "can't allocate CAM SIM for controller %d\n", i
);
2410 if (xpt_bus_register(sc
->ciss_cam_sim
[i
], i
) != 0) {
2411 ciss_printf(sc
, "can't register SCSI bus %d\n", i
);
2417 * Initiate a rescan of the bus.
2419 ciss_cam_rescan_all(sc
);
2424 /************************************************************************
2425 * Initiate a rescan of the 'logical devices' SIM
2428 ciss_cam_rescan_target(struct ciss_softc
*sc
, int bus
, int target
)
2430 struct cam_path
*path
;
2435 ccb
= kmalloc(sizeof(union ccb
), M_TEMP
, M_WAITOK
| M_ZERO
);
2437 if (xpt_create_path(&path
, xpt_periph
, cam_sim_path(sc
->ciss_cam_sim
[bus
]),
2438 target
, CAM_LUN_WILDCARD
) != CAM_REQ_CMP
) {
2439 ciss_printf(sc
, "rescan failed (can't create path)\n");
2444 xpt_setup_ccb(&ccb
->ccb_h
, path
, 5/*priority (low)*/);
2445 ccb
->ccb_h
.func_code
= XPT_SCAN_BUS
;
2446 ccb
->ccb_h
.cbfcnp
= ciss_cam_rescan_callback
;
2447 ccb
->crcn
.flags
= CAM_FLAG_NONE
;
2450 /* scan is now in progress */
2454 ciss_cam_rescan_all(struct ciss_softc
*sc
)
2458 /* Rescan the logical buses */
2459 for (i
= 0; i
< sc
->ciss_max_logical_bus
; i
++)
2460 ciss_cam_rescan_target(sc
, i
, CAM_TARGET_WILDCARD
);
2461 /* Rescan the physical buses */
2462 for (i
= CISS_PHYSICAL_BASE
; i
< sc
->ciss_max_physical_bus
+
2463 CISS_PHYSICAL_BASE
; i
++)
2464 ciss_cam_rescan_target(sc
, i
, CAM_TARGET_WILDCARD
);
2468 ciss_cam_rescan_callback(struct cam_periph
*periph
, union ccb
*ccb
)
2470 xpt_free_path(ccb
->ccb_h
.path
);
2474 /************************************************************************
2475 * Handle requests coming from CAM
2478 ciss_cam_action(struct cam_sim
*sim
, union ccb
*ccb
)
2480 struct ciss_softc
*sc
;
2481 struct ccb_scsiio
*csio
;
2485 sc
= cam_sim_softc(sim
);
2486 bus
= cam_sim_bus(sim
);
2487 csio
= (struct ccb_scsiio
*)&ccb
->csio
;
2488 target
= csio
->ccb_h
.target_id
;
2489 physical
= CISS_IS_PHYSICAL(bus
);
2491 switch (ccb
->ccb_h
.func_code
) {
2493 /* perform SCSI I/O */
2495 if (!ciss_cam_action_io(sim
, csio
))
2499 /* perform geometry calculations */
2500 case XPT_CALC_GEOMETRY
:
2502 struct ccb_calc_geometry
*ccg
= &ccb
->ccg
;
2503 struct ciss_ldrive
*ld
;
2505 debug(1, "XPT_CALC_GEOMETRY %d:%d:%d", cam_sim_bus(sim
), ccb
->ccb_h
.target_id
, ccb
->ccb_h
.target_lun
);
2509 ld
= &sc
->ciss_logical
[bus
][target
];
2512 * Use the cached geometry settings unless the fault tolerance
2515 if (physical
|| ld
->cl_geometry
.fault_tolerance
== 0xFF) {
2516 u_int32_t secs_per_cylinder
;
2519 ccg
->secs_per_track
= 32;
2520 secs_per_cylinder
= ccg
->heads
* ccg
->secs_per_track
;
2521 ccg
->cylinders
= ccg
->volume_size
/ secs_per_cylinder
;
2523 ccg
->heads
= ld
->cl_geometry
.heads
;
2524 ccg
->secs_per_track
= ld
->cl_geometry
.sectors
;
2525 ccg
->cylinders
= ntohs(ld
->cl_geometry
.cylinders
);
2527 ccb
->ccb_h
.status
= CAM_REQ_CMP
;
2531 /* handle path attribute inquiry */
2534 struct ccb_pathinq
*cpi
= &ccb
->cpi
;
2536 debug(1, "XPT_PATH_INQ %d:%d:%d", cam_sim_bus(sim
), ccb
->ccb_h
.target_id
, ccb
->ccb_h
.target_lun
);
2538 cpi
->version_num
= 1;
2539 cpi
->hba_inquiry
= PI_TAG_ABLE
; /* XXX is this correct? */
2540 cpi
->target_sprt
= 0;
2542 cpi
->max_target
= CISS_MAX_LOGICAL
;
2543 cpi
->max_lun
= 0; /* 'logical drive' channel only */
2544 cpi
->initiator_id
= CISS_MAX_LOGICAL
;
2545 strncpy(cpi
->sim_vid
, "FreeBSD", SIM_IDLEN
);
2546 strncpy(cpi
->hba_vid
, "msmith@freebsd.org", HBA_IDLEN
);
2547 strncpy(cpi
->dev_name
, cam_sim_name(sim
), DEV_IDLEN
);
2548 cpi
->unit_number
= cam_sim_unit(sim
);
2549 cpi
->bus_id
= cam_sim_bus(sim
);
2550 cpi
->base_transfer_speed
= 132 * 1024; /* XXX what to set this to? */
2551 cpi
->transport
= XPORT_SPI
;
2552 cpi
->transport_version
= 2;
2553 cpi
->protocol
= PROTO_SCSI
;
2554 cpi
->protocol_version
= SCSI_REV_2
;
2555 ccb
->ccb_h
.status
= CAM_REQ_CMP
;
2559 case XPT_GET_TRAN_SETTINGS
:
2561 struct ccb_trans_settings
*cts
= &ccb
->cts
;
2563 struct ccb_trans_settings_spi
*spi
=
2564 &cts
->xport_specific
.spi
;
2566 bus
= cam_sim_bus(sim
);
2567 target
= cts
->ccb_h
.target_id
;
2569 debug(1, "XPT_GET_TRAN_SETTINGS %d:%d", bus
, target
);
2570 /* disconnect always OK */
2571 cts
->protocol
= PROTO_SCSI
;
2572 cts
->protocol_version
= SCSI_REV_2
;
2573 cts
->transport
= XPORT_SPI
;
2574 cts
->transport_version
= 2;
2576 spi
->valid
= CTS_SPI_VALID_DISC
;
2577 spi
->flags
= CTS_SPI_FLAGS_DISC_ENB
;
2579 cts
->ccb_h
.status
= CAM_REQ_CMP
;
2583 default: /* we can't do this */
2584 debug(1, "unsupported func_code = 0x%x", ccb
->ccb_h
.func_code
);
2585 ccb
->ccb_h
.status
= CAM_REQ_INVALID
;
2592 /************************************************************************
2593 * Handle a CAM SCSI I/O request.
2596 ciss_cam_action_io(struct cam_sim
*sim
, struct ccb_scsiio
*csio
)
2598 struct ciss_softc
*sc
;
2600 struct ciss_request
*cr
;
2601 struct ciss_command
*cc
;
2604 sc
= cam_sim_softc(sim
);
2605 bus
= cam_sim_bus(sim
);
2606 target
= csio
->ccb_h
.target_id
;
2608 debug(2, "XPT_SCSI_IO %d:%d:%d", bus
, target
, csio
->ccb_h
.target_lun
);
2610 /* check that the CDB pointer is not to a physical address */
2611 if ((csio
->ccb_h
.flags
& CAM_CDB_POINTER
) && (csio
->ccb_h
.flags
& CAM_CDB_PHYS
)) {
2612 debug(3, " CDB pointer is to physical address");
2613 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2616 /* if there is data transfer, it must be to/from a virtual address */
2617 if ((csio
->ccb_h
.flags
& CAM_DIR_MASK
) != CAM_DIR_NONE
) {
2618 if (csio
->ccb_h
.flags
& CAM_DATA_PHYS
) { /* we can't map it */
2619 debug(3, " data pointer is to physical address");
2620 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2622 if (csio
->ccb_h
.flags
& CAM_SCATTER_VALID
) { /* we want to do the s/g setup */
2623 debug(3, " data has premature s/g setup");
2624 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2628 /* abandon aborted ccbs or those that have failed validation */
2629 if ((csio
->ccb_h
.status
& CAM_STATUS_MASK
) != CAM_REQ_INPROG
) {
2630 debug(3, "abandoning CCB due to abort/validation failure");
2634 /* handle emulation of some SCSI commands ourself */
2635 if (ciss_cam_emulate(sc
, csio
))
2639 * Get a request to manage this command. If we can't, return the
2640 * ccb, freeze the queue and flag so that we unfreeze it when a
2641 * request completes.
2643 if ((error
= ciss_get_request(sc
, &cr
)) != 0) {
2644 xpt_freeze_simq(sim
, 1);
2645 csio
->ccb_h
.status
|= CAM_REQUEUE_REQ
;
2650 * Build the command.
2652 cc
= CISS_FIND_COMMAND(cr
);
2653 cr
->cr_data
= csio
->data_ptr
;
2654 cr
->cr_length
= csio
->dxfer_len
;
2655 cr
->cr_complete
= ciss_cam_complete
;
2656 cr
->cr_private
= csio
;
2659 * Target the right logical volume.
2661 if (CISS_IS_PHYSICAL(bus
))
2662 cc
->header
.address
=
2663 sc
->ciss_physical
[CISS_CAM_TO_PBUS(bus
)][target
].cp_address
;
2665 cc
->header
.address
=
2666 sc
->ciss_logical
[bus
][target
].cl_address
;
2667 cc
->cdb
.cdb_length
= csio
->cdb_len
;
2668 cc
->cdb
.type
= CISS_CDB_TYPE_COMMAND
;
2669 cc
->cdb
.attribute
= CISS_CDB_ATTRIBUTE_SIMPLE
; /* XXX ordered tags? */
2670 if ((csio
->ccb_h
.flags
& CAM_DIR_MASK
) == CAM_DIR_OUT
) {
2671 cr
->cr_flags
= CISS_REQ_DATAOUT
;
2672 cc
->cdb
.direction
= CISS_CDB_DIRECTION_WRITE
;
2673 } else if ((csio
->ccb_h
.flags
& CAM_DIR_MASK
) == CAM_DIR_IN
) {
2674 cr
->cr_flags
= CISS_REQ_DATAIN
;
2675 cc
->cdb
.direction
= CISS_CDB_DIRECTION_READ
;
2678 cc
->cdb
.direction
= CISS_CDB_DIRECTION_NONE
;
2680 cc
->cdb
.timeout
= (csio
->ccb_h
.timeout
/ 1000) + 1;
2681 if (csio
->ccb_h
.flags
& CAM_CDB_POINTER
) {
2682 bcopy(csio
->cdb_io
.cdb_ptr
, &cc
->cdb
.cdb
[0], csio
->cdb_len
);
2684 bcopy(csio
->cdb_io
.cdb_bytes
, &cc
->cdb
.cdb
[0], csio
->cdb_len
);
2688 * Submit the request to the adapter.
2690 * Note that this may fail if we're unable to map the request (and
2691 * if we ever learn a transport layer other than simple, may fail
2692 * if the adapter rejects the command).
2694 if ((error
= ciss_start(cr
)) != 0) {
2695 xpt_freeze_simq(sim
, 1);
2696 if (error
== EINPROGRESS
) {
2697 csio
->ccb_h
.status
|= CAM_RELEASE_SIMQ
;
2700 csio
->ccb_h
.status
|= CAM_REQUEUE_REQ
;
2701 ciss_release_request(cr
);
2709 /************************************************************************
2710 * Emulate SCSI commands the adapter doesn't handle as we might like.
2713 ciss_cam_emulate(struct ciss_softc
*sc
, struct ccb_scsiio
*csio
)
2718 target
= csio
->ccb_h
.target_id
;
2719 bus
= cam_sim_bus(xpt_path_sim(csio
->ccb_h
.path
));
2720 opcode
= (csio
->ccb_h
.flags
& CAM_CDB_POINTER
) ?
2721 *(u_int8_t
*)csio
->cdb_io
.cdb_ptr
: csio
->cdb_io
.cdb_bytes
[0];
2723 if (CISS_IS_PHYSICAL(bus
)) {
2724 if (sc
->ciss_physical
[CISS_CAM_TO_PBUS(bus
)][target
].cp_online
!= 1) {
2725 csio
->ccb_h
.status
= CAM_SEL_TIMEOUT
;
2726 xpt_done((union ccb
*)csio
);
2733 * Handle requests for volumes that don't exist or are not online.
2734 * A selection timeout is slightly better than an illegal request.
2735 * Other errors might be better.
2737 if (sc
->ciss_logical
[bus
][target
].cl_status
!= CISS_LD_ONLINE
) {
2738 csio
->ccb_h
.status
= CAM_SEL_TIMEOUT
;
2739 xpt_done((union ccb
*)csio
);
2743 /* if we have to fake Synchronise Cache */
2744 if (sc
->ciss_flags
& CISS_FLAG_FAKE_SYNCH
) {
2746 * If this is a Synchronise Cache command, typically issued when
2747 * a device is closed, flush the adapter and complete now.
2749 if (((csio
->ccb_h
.flags
& CAM_CDB_POINTER
) ?
2750 *(u_int8_t
*)csio
->cdb_io
.cdb_ptr
: csio
->cdb_io
.cdb_bytes
[0]) == SYNCHRONIZE_CACHE
) {
2751 ciss_flush_adapter(sc
);
2752 csio
->ccb_h
.status
= CAM_REQ_CMP
;
2753 xpt_done((union ccb
*)csio
);
2761 /************************************************************************
2762 * Check for possibly-completed commands.
2765 ciss_cam_poll(struct cam_sim
*sim
)
2767 struct ciss_softc
*sc
= cam_sim_softc(sim
);
2774 /************************************************************************
2775 * Handle completion of a command - pass results back through the CCB
2778 ciss_cam_complete(struct ciss_request
*cr
)
2780 struct ciss_softc
*sc
;
2781 struct ciss_command
*cc
;
2782 struct ciss_error_info
*ce
;
2783 struct ccb_scsiio
*csio
;
2790 cc
= CISS_FIND_COMMAND(cr
);
2791 ce
= (struct ciss_error_info
*)&(cc
->sg
[0]);
2792 csio
= (struct ccb_scsiio
*)cr
->cr_private
;
2795 * Extract status values from request.
2797 ciss_report_request(cr
, &command_status
, &scsi_status
);
2798 csio
->scsi_status
= scsi_status
;
2801 * Handle specific SCSI status values.
2803 switch(scsi_status
) {
2804 /* no status due to adapter error */
2806 debug(0, "adapter error");
2807 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2810 /* no status due to command completed OK */
2811 case SCSI_STATUS_OK
: /* CISS_SCSI_STATUS_GOOD */
2812 debug(2, "SCSI_STATUS_OK");
2813 csio
->ccb_h
.status
= CAM_REQ_CMP
;
2816 /* check condition, sense data included */
2817 case SCSI_STATUS_CHECK_COND
: /* CISS_SCSI_STATUS_CHECK_CONDITION */
2818 debug(0, "SCSI_STATUS_CHECK_COND sense size %d resid %d\n",
2819 ce
->sense_length
, ce
->residual_count
);
2820 bzero(&csio
->sense_data
, SSD_FULL_SIZE
);
2821 bcopy(&ce
->sense_info
[0], &csio
->sense_data
, ce
->sense_length
);
2822 csio
->sense_len
= ce
->sense_length
;
2823 csio
->resid
= ce
->residual_count
;
2824 csio
->ccb_h
.status
= CAM_SCSI_STATUS_ERROR
| CAM_AUTOSNS_VALID
;
2827 struct scsi_sense_data
*sns
= (struct scsi_sense_data
*)&ce
->sense_info
[0];
2828 debug(0, "sense key %x", sns
->flags
& SSD_KEY
);
2833 case SCSI_STATUS_BUSY
: /* CISS_SCSI_STATUS_BUSY */
2834 debug(0, "SCSI_STATUS_BUSY");
2835 csio
->ccb_h
.status
= CAM_SCSI_BUSY
;
2839 debug(0, "unknown status 0x%x", csio
->scsi_status
);
2840 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2844 /* handle post-command fixup */
2845 ciss_cam_complete_fixup(sc
, csio
);
2847 /* tell CAM we're ready for more commands */
2848 csio
->ccb_h
.status
|= CAM_RELEASE_SIMQ
;
2850 xpt_done((union ccb
*)csio
);
2851 ciss_release_request(cr
);
2854 /********************************************************************************
2855 * Fix up the result of some commands here.
2858 ciss_cam_complete_fixup(struct ciss_softc
*sc
, struct ccb_scsiio
*csio
)
2860 struct scsi_inquiry_data
*inq
;
2861 struct ciss_ldrive
*cl
;
2864 if (((csio
->ccb_h
.flags
& CAM_CDB_POINTER
) ?
2865 *(u_int8_t
*)csio
->cdb_io
.cdb_ptr
: csio
->cdb_io
.cdb_bytes
[0]) == INQUIRY
) {
2867 inq
= (struct scsi_inquiry_data
*)csio
->data_ptr
;
2868 target
= csio
->ccb_h
.target_id
;
2869 bus
= cam_sim_bus(xpt_path_sim(csio
->ccb_h
.path
));
2872 * Don't let hard drives be seen by the DA driver. They will still be
2873 * attached by the PASS driver.
2875 if (CISS_IS_PHYSICAL(bus
)) {
2876 if (SID_TYPE(inq
) == T_DIRECT
)
2877 inq
->device
= (inq
->device
& 0xe0) | T_NODEVICE
;
2881 cl
= &sc
->ciss_logical
[bus
][target
];
2883 padstr(inq
->vendor
, "COMPAQ", 8);
2884 padstr(inq
->product
, ciss_name_ldrive_org(cl
->cl_ldrive
->fault_tolerance
), 8);
2885 padstr(inq
->revision
, ciss_name_ldrive_status(cl
->cl_lstatus
->status
), 16);
2890 /********************************************************************************
2891 * Find a peripheral attached at (target)
2893 static struct cam_periph
*
2894 ciss_find_periph(struct ciss_softc
*sc
, int bus
, int target
)
2896 struct cam_periph
*periph
;
2897 struct cam_path
*path
;
2900 status
= xpt_create_path(&path
, NULL
, cam_sim_path(sc
->ciss_cam_sim
[bus
]),
2902 if (status
== CAM_REQ_CMP
) {
2903 periph
= cam_periph_find(path
, NULL
);
2904 xpt_free_path(path
);
2911 /********************************************************************************
2912 * Name the device at (target)
2914 * XXX is this strictly correct?
2917 ciss_name_device(struct ciss_softc
*sc
, int bus
, int target
)
2919 struct cam_periph
*periph
;
2921 if (CISS_IS_PHYSICAL(bus
))
2923 if ((periph
= ciss_find_periph(sc
, bus
, target
)) != NULL
) {
2924 ksprintf(sc
->ciss_logical
[bus
][target
].cl_name
, "%s%d",
2925 periph
->periph_name
, periph
->unit_number
);
2928 sc
->ciss_logical
[bus
][target
].cl_name
[0] = 0;
2932 /************************************************************************
2933 * Periodic status monitoring.
2936 ciss_periodic(void *arg
)
2938 struct ciss_softc
*sc
;
2942 sc
= (struct ciss_softc
*)arg
;
2945 * Check the adapter heartbeat.
2947 if (sc
->ciss_cfg
->heartbeat
== sc
->ciss_heartbeat
) {
2948 sc
->ciss_heart_attack
++;
2949 debug(0, "adapter heart attack in progress 0x%x/%d",
2950 sc
->ciss_heartbeat
, sc
->ciss_heart_attack
);
2951 if (sc
->ciss_heart_attack
== 3) {
2952 ciss_printf(sc
, "ADAPTER HEARTBEAT FAILED\n");
2953 /* XXX should reset adapter here */
2956 sc
->ciss_heartbeat
= sc
->ciss_cfg
->heartbeat
;
2957 sc
->ciss_heart_attack
= 0;
2958 debug(3, "new heartbeat 0x%x", sc
->ciss_heartbeat
);
2962 * If the notify event request has died for some reason, or has
2963 * not started yet, restart it.
2965 if (!(sc
->ciss_flags
& CISS_FLAG_NOTIFY_OK
)) {
2966 debug(0, "(re)starting Event Notify chain");
2967 ciss_notify_event(sc
);
2973 if (!(sc
->ciss_flags
& CISS_FLAG_ABORTING
))
2974 callout_reset(&sc
->ciss_periodic
, CISS_HEARTBEAT_RATE
* hz
,
2978 /************************************************************************
2979 * Request a notification response from the adapter.
2981 * If (cr) is NULL, this is the first request of the adapter, so
2982 * reset the adapter's message pointer and start with the oldest
2983 * message available.
2986 ciss_notify_event(struct ciss_softc
*sc
)
2988 struct ciss_request
*cr
;
2989 struct ciss_command
*cc
;
2990 struct ciss_notify_cdb
*cnc
;
2995 cr
= sc
->ciss_periodic_notify
;
2997 /* get a request if we don't already have one */
2999 if ((error
= ciss_get_request(sc
, &cr
)) != 0) {
3000 debug(0, "can't get notify event request");
3003 sc
->ciss_periodic_notify
= cr
;
3004 cr
->cr_complete
= ciss_notify_complete
;
3005 debug(1, "acquired request %d", cr
->cr_tag
);
3009 * Get a databuffer if we don't already have one, note that the
3010 * adapter command wants a larger buffer than the actual
3013 if (cr
->cr_data
== NULL
) {
3014 cr
->cr_data
= kmalloc(CISS_NOTIFY_DATA_SIZE
, CISS_MALLOC_CLASS
, M_INTWAIT
);
3015 cr
->cr_length
= CISS_NOTIFY_DATA_SIZE
;
3018 /* re-setup the request's command (since we never release it) XXX overkill*/
3019 ciss_preen_command(cr
);
3021 /* (re)build the notify event command */
3022 cc
= CISS_FIND_COMMAND(cr
);
3023 cc
->header
.address
.physical
.mode
= CISS_HDR_ADDRESS_MODE_PERIPHERAL
;
3024 cc
->header
.address
.physical
.bus
= 0;
3025 cc
->header
.address
.physical
.target
= 0;
3027 cc
->cdb
.cdb_length
= sizeof(*cnc
);
3028 cc
->cdb
.type
= CISS_CDB_TYPE_COMMAND
;
3029 cc
->cdb
.attribute
= CISS_CDB_ATTRIBUTE_SIMPLE
;
3030 cc
->cdb
.direction
= CISS_CDB_DIRECTION_READ
;
3031 cc
->cdb
.timeout
= 0; /* no timeout, we hope */
3033 cnc
= (struct ciss_notify_cdb
*)&(cc
->cdb
.cdb
[0]);
3034 bzero(cr
->cr_data
, CISS_NOTIFY_DATA_SIZE
);
3035 cnc
->opcode
= CISS_OPCODE_READ
;
3036 cnc
->command
= CISS_COMMAND_NOTIFY_ON_EVENT
;
3037 cnc
->timeout
= 0; /* no timeout, we hope */
3038 cnc
->synchronous
= 0;
3040 cnc
->seek_to_oldest
= 0;
3041 if ((sc
->ciss_flags
& CISS_FLAG_RUNNING
) == 0)
3045 cnc
->length
= htonl(CISS_NOTIFY_DATA_SIZE
);
3047 /* submit the request */
3048 error
= ciss_start(cr
);
3053 if (cr
->cr_data
!= NULL
)
3054 kfree(cr
->cr_data
, CISS_MALLOC_CLASS
);
3055 ciss_release_request(cr
);
3057 sc
->ciss_periodic_notify
= NULL
;
3058 debug(0, "can't submit notify event request");
3059 sc
->ciss_flags
&= ~CISS_FLAG_NOTIFY_OK
;
3061 debug(1, "notify event submitted");
3062 sc
->ciss_flags
|= CISS_FLAG_NOTIFY_OK
;
3067 ciss_notify_complete(struct ciss_request
*cr
)
3069 struct ciss_command
*cc
;
3070 struct ciss_notify
*cn
;
3071 struct ciss_softc
*sc
;
3076 cc
= CISS_FIND_COMMAND(cr
);
3077 cn
= (struct ciss_notify
*)cr
->cr_data
;
3081 * Report request results, decode status.
3083 ciss_report_request(cr
, &command_status
, &scsi_status
);
3086 * Abort the chain on a fatal error.
3088 * XXX which of these are actually errors?
3090 if ((command_status
!= CISS_CMD_STATUS_SUCCESS
) &&
3091 (command_status
!= CISS_CMD_STATUS_TARGET_STATUS
) &&
3092 (command_status
!= CISS_CMD_STATUS_TIMEOUT
)) { /* XXX timeout? */
3093 ciss_printf(sc
, "fatal error in Notify Event request (%s)\n",
3094 ciss_name_command_status(command_status
));
3095 ciss_release_request(cr
);
3096 sc
->ciss_flags
&= ~CISS_FLAG_NOTIFY_OK
;
3101 * If the adapter gave us a text message, print it.
3103 if (cn
->message
[0] != 0)
3104 ciss_printf(sc
, "*** %.80s\n", cn
->message
);
3106 debug(0, "notify event class %d subclass %d detail %d",
3107 cn
->class, cn
->subclass
, cn
->detail
);
3110 * If the response indicates that the notifier has been aborted,
3111 * release the notifier command.
3113 if ((cn
->class == CISS_NOTIFY_NOTIFIER
) &&
3114 (cn
->subclass
== CISS_NOTIFY_NOTIFIER_STATUS
) &&
3115 (cn
->detail
== 1)) {
3116 debug(0, "notifier exiting");
3117 sc
->ciss_flags
&= ~CISS_FLAG_NOTIFY_OK
;
3118 ciss_release_request(cr
);
3119 sc
->ciss_periodic_notify
= NULL
;
3120 wakeup(&sc
->ciss_periodic_notify
);
3122 /* Handle notify events in a kernel thread */
3123 ciss_enqueue_notify(cr
);
3124 sc
->ciss_periodic_notify
= NULL
;
3125 wakeup(&sc
->ciss_periodic_notify
);
3126 wakeup(&sc
->ciss_notify
);
3129 * Send a new notify event command, if we're not aborting.
3131 if (!(sc
->ciss_flags
& CISS_FLAG_ABORTING
)) {
3132 ciss_notify_event(sc
);
3136 /************************************************************************
3137 * Abort the Notify Event chain.
3139 * Note that we can't just abort the command in progress; we have to
3140 * explicitly issue an Abort Notify Event command in order for the
3141 * adapter to clean up correctly.
3143 * If we are called with CISS_FLAG_ABORTING set in the adapter softc,
3144 * the chain will not restart itself.
3147 ciss_notify_abort(struct ciss_softc
*sc
)
3149 struct ciss_request
*cr
;
3150 struct ciss_command
*cc
;
3151 struct ciss_notify_cdb
*cnc
;
3152 int error
, command_status
, scsi_status
;
3159 /* verify that there's an outstanding command */
3160 if (!(sc
->ciss_flags
& CISS_FLAG_NOTIFY_OK
))
3163 /* get a command to issue the abort with */
3164 if ((error
= ciss_get_request(sc
, &cr
)))
3167 /* get a buffer for the result */
3168 cr
->cr_data
= kmalloc(CISS_NOTIFY_DATA_SIZE
, CISS_MALLOC_CLASS
, M_INTWAIT
);
3169 cr
->cr_length
= CISS_NOTIFY_DATA_SIZE
;
3172 cc
= CISS_FIND_COMMAND(cr
);
3173 cc
->header
.address
.physical
.mode
= CISS_HDR_ADDRESS_MODE_PERIPHERAL
;
3174 cc
->header
.address
.physical
.bus
= 0;
3175 cc
->header
.address
.physical
.target
= 0;
3176 cc
->cdb
.cdb_length
= sizeof(*cnc
);
3177 cc
->cdb
.type
= CISS_CDB_TYPE_COMMAND
;
3178 cc
->cdb
.attribute
= CISS_CDB_ATTRIBUTE_SIMPLE
;
3179 cc
->cdb
.direction
= CISS_CDB_DIRECTION_READ
;
3180 cc
->cdb
.timeout
= 0; /* no timeout, we hope */
3182 cnc
= (struct ciss_notify_cdb
*)&(cc
->cdb
.cdb
[0]);
3183 bzero(cnc
, sizeof(*cnc
));
3184 cnc
->opcode
= CISS_OPCODE_WRITE
;
3185 cnc
->command
= CISS_COMMAND_ABORT_NOTIFY
;
3186 cnc
->length
= htonl(CISS_NOTIFY_DATA_SIZE
);
3188 ciss_print_request(cr
);
3191 * Submit the request and wait for it to complete.
3193 if ((error
= ciss_synch_request(cr
, 60 * 1000)) != 0) {
3194 ciss_printf(sc
, "Abort Notify Event command failed (%d)\n", error
);
3201 ciss_report_request(cr
, &command_status
, &scsi_status
);
3202 switch(command_status
) {
3203 case CISS_CMD_STATUS_SUCCESS
:
3205 case CISS_CMD_STATUS_INVALID_COMMAND
:
3207 * Some older adapters don't support the CISS version of this
3208 * command. Fall back to using the BMIC version.
3210 error
= ciss_notify_abort_bmic(sc
);
3215 case CISS_CMD_STATUS_TARGET_STATUS
:
3217 * This can happen if the adapter thinks there wasn't an outstanding
3218 * Notify Event command but we did. We clean up here.
3220 if (scsi_status
== CISS_SCSI_STATUS_CHECK_CONDITION
) {
3221 if (sc
->ciss_periodic_notify
!= NULL
)
3222 ciss_release_request(sc
->ciss_periodic_notify
);
3229 ciss_printf(sc
, "Abort Notify Event command failed (%s)\n",
3230 ciss_name_command_status(command_status
));
3236 * Sleep waiting for the notifier command to complete. Note
3237 * that if it doesn't, we may end up in a bad situation, since
3238 * the adapter may deliver it later. Also note that the adapter
3239 * requires the Notify Event command to be cancelled in order to
3240 * maintain internal bookkeeping.
3243 while (sc
->ciss_periodic_notify
!= NULL
) {
3244 error
= tsleep(&sc
->ciss_periodic_notify
, 0, "cissNEA", hz
* 5);
3245 if (error
== EWOULDBLOCK
) {
3246 ciss_printf(sc
, "Notify Event command failed to abort, adapter may wedge.\n");
3253 /* release the cancel request */
3255 if (cr
->cr_data
!= NULL
)
3256 kfree(cr
->cr_data
, CISS_MALLOC_CLASS
);
3257 ciss_release_request(cr
);
3260 sc
->ciss_flags
&= ~CISS_FLAG_NOTIFY_OK
;
3264 /************************************************************************
3265 * Abort the Notify Event chain using a BMIC command.
3268 ciss_notify_abort_bmic(struct ciss_softc
*sc
)
3270 struct ciss_request
*cr
;
3271 int error
, command_status
;
3278 /* verify that there's an outstanding command */
3279 if (!(sc
->ciss_flags
& CISS_FLAG_NOTIFY_OK
))
3283 * Build a BMIC command to cancel the Notify on Event command.
3285 * Note that we are sending a CISS opcode here. Odd.
3287 if ((error
= ciss_get_bmic_request(sc
, &cr
, CISS_COMMAND_ABORT_NOTIFY
,
3292 * Submit the request and wait for it to complete.
3294 if ((error
= ciss_synch_request(cr
, 60 * 1000)) != 0) {
3295 ciss_printf(sc
, "error sending BMIC Cancel Notify on Event command (%d)\n", error
);
3302 ciss_report_request(cr
, &command_status
, NULL
);
3303 switch(command_status
) {
3304 case CISS_CMD_STATUS_SUCCESS
:
3307 ciss_printf(sc
, "error cancelling Notify on Event (%s)\n",
3308 ciss_name_command_status(command_status
));
3315 ciss_release_request(cr
);
3319 /************************************************************************
3320 * Handle rescanning all the logical volumes when a notify event
3321 * causes the drives to come online or offline.
3324 ciss_notify_rescan_logical(struct ciss_softc
*sc
)
3326 struct ciss_lun_report
*cll
;
3327 struct ciss_ldrive
*ld
;
3331 * We must rescan all logical volumes to get the right logical
3334 cll
= ciss_report_luns(sc
, CISS_OPCODE_REPORT_LOGICAL_LUNS
,
3339 ndrives
= (ntohl(cll
->list_size
) / sizeof(union ciss_device_address
));
3342 * Delete any of the drives which were destroyed by the
3345 for (i
= 0; i
< sc
->ciss_max_logical_bus
; i
++) {
3346 for (j
= 0; j
< CISS_MAX_LOGICAL
; j
++) {
3347 ld
= &sc
->ciss_logical
[i
][j
];
3349 if (ld
->cl_update
== 0)
3352 if (ld
->cl_status
!= CISS_LD_ONLINE
) {
3353 ciss_cam_rescan_target(sc
, i
, j
);
3356 kfree(ld
->cl_ldrive
, CISS_MALLOC_CLASS
);
3358 kfree(ld
->cl_lstatus
, CISS_MALLOC_CLASS
);
3360 ld
->cl_ldrive
= NULL
;
3361 ld
->cl_lstatus
= NULL
;
3367 * Scan for new drives.
3369 for (i
= 0; i
< ndrives
; i
++) {
3372 bus
= CISS_LUN_TO_BUS(cll
->lun
[i
].logical
.lun
);
3373 target
= CISS_LUN_TO_TARGET(cll
->lun
[i
].logical
.lun
);
3374 ld
= &sc
->ciss_logical
[bus
][target
];
3376 if (ld
->cl_update
== 0)
3380 ld
->cl_address
= cll
->lun
[i
];
3381 ld
->cl_controller
= &sc
->ciss_controllers
[bus
];
3382 if (ciss_identify_logical(sc
, ld
) == 0) {
3383 ciss_cam_rescan_target(sc
, bus
, target
);
3386 kfree(cll
, CISS_MALLOC_CLASS
);
3389 /************************************************************************
3390 * Handle a notify event relating to the status of a logical drive.
3392 * XXX need to be able to defer some of these to properly handle
3393 * calling the "ID Physical drive" command, unless the 'extended'
3394 * drive IDs are always in BIG_MAP format.
3397 ciss_notify_logical(struct ciss_softc
*sc
, struct ciss_notify
*cn
)
3399 struct ciss_ldrive
*ld
;
3400 int ostatus
, bus
, target
;
3404 bus
= cn
->device
.physical
.bus
;
3405 target
= cn
->data
.logical_status
.logical_drive
;
3406 ld
= &sc
->ciss_logical
[bus
][target
];
3408 switch (cn
->subclass
) {
3409 case CISS_NOTIFY_LOGICAL_STATUS
:
3410 switch (cn
->detail
) {
3412 ciss_name_device(sc
, bus
, target
);
3413 ciss_printf(sc
, "logical drive %d (%s) changed status %s->%s, spare status 0x%b\n",
3414 cn
->data
.logical_status
.logical_drive
, ld
->cl_name
,
3415 ciss_name_ldrive_status(cn
->data
.logical_status
.previous_state
),
3416 ciss_name_ldrive_status(cn
->data
.logical_status
.new_state
),
3417 cn
->data
.logical_status
.spare_state
,
3418 "\20\1configured\2rebuilding\3failed\4in use\5available\n");
3421 * Update our idea of the drive's status.
3423 ostatus
= ciss_decode_ldrive_status(cn
->data
.logical_status
.previous_state
);
3424 ld
->cl_status
= ciss_decode_ldrive_status(cn
->data
.logical_status
.new_state
);
3425 if (ld
->cl_lstatus
!= NULL
)
3426 ld
->cl_lstatus
->status
= cn
->data
.logical_status
.new_state
;
3429 * Have CAM rescan the drive if its status has changed.
3431 if (ostatus
!= ld
->cl_status
) {
3433 ciss_notify_rescan_logical(sc
);
3438 case 1: /* logical drive has recognised new media, needs Accept Media Exchange */
3439 ciss_name_device(sc
, bus
, target
);
3440 ciss_printf(sc
, "logical drive %d (%s) media exchanged, ready to go online\n",
3441 cn
->data
.logical_status
.logical_drive
, ld
->cl_name
);
3442 ciss_accept_media(sc
, ld
);
3445 ld
->cl_status
= ciss_decode_ldrive_status(cn
->data
.logical_status
.new_state
);
3446 ciss_notify_rescan_logical(sc
);
3451 ciss_printf(sc
, "rebuild of logical drive %d (%s) failed due to %s error\n",
3452 cn
->data
.rebuild_aborted
.logical_drive
,
3454 (cn
->detail
== 2) ? "read" : "write");
3459 case CISS_NOTIFY_LOGICAL_ERROR
:
3460 if (cn
->detail
== 0) {
3461 ciss_printf(sc
, "FATAL I/O ERROR on logical drive %d (%s), SCSI port %d ID %d\n",
3462 cn
->data
.io_error
.logical_drive
,
3464 cn
->data
.io_error
.failure_bus
,
3465 cn
->data
.io_error
.failure_drive
);
3466 /* XXX should we take the drive down at this point, or will we be told? */
3470 case CISS_NOTIFY_LOGICAL_SURFACE
:
3471 if (cn
->detail
== 0)
3472 ciss_printf(sc
, "logical drive %d (%s) completed consistency initialisation\n",
3473 cn
->data
.consistency_completed
.logical_drive
,
3479 /************************************************************************
3480 * Handle a notify event relating to the status of a physical drive.
3483 ciss_notify_physical(struct ciss_softc
*sc
, struct ciss_notify
*cn
)
3487 /************************************************************************
3488 * Handle a notify event relating to the status of a physical drive.
3491 ciss_notify_hotplug(struct ciss_softc
*sc
, struct ciss_notify
*cn
)
3493 struct ciss_lun_report
*cll
;
3496 switch (cn
->subclass
) {
3497 case CISS_NOTIFY_HOTPLUG_PHYSICAL
:
3498 case CISS_NOTIFY_HOTPLUG_NONDISK
:
3499 bus
= CISS_BIG_MAP_BUS(sc
, cn
->data
.drive
.big_physical_drive_number
);
3501 CISS_BIG_MAP_TARGET(sc
, cn
->data
.drive
.big_physical_drive_number
);
3504 if (cn
->detail
== 0) {
3506 * Mark the device offline so that it'll start producing selection
3507 * timeouts to the upper layer.
3509 sc
->ciss_physical
[bus
][target
].cp_online
= 0;
3512 * Rescan the physical lun list for new items
3514 cll
= ciss_report_luns(sc
, CISS_OPCODE_REPORT_PHYSICAL_LUNS
,
3517 ciss_printf(sc
, "Warning, cannot get physical lun list\n");
3520 ciss_filter_physical(sc
, cll
);
3526 ciss_printf(sc
, "Unknown hotplug event %d\n", cn
->subclass
);
3531 /************************************************************************
3532 * Handle deferred processing of notify events. Notify events may need
3533 * sleep which is unsafe during an interrupt.
3536 ciss_notify_thread(void *arg
)
3538 struct ciss_softc
*sc
;
3539 struct ciss_request
*cr
;
3540 struct ciss_notify
*cn
;
3542 sc
= (struct ciss_softc
*)arg
;
3546 if (TAILQ_EMPTY(&sc
->ciss_notify
) != 0 &&
3547 (sc
->ciss_flags
& CISS_FLAG_THREAD_SHUT
) == 0) {
3548 tsleep(&sc
->ciss_notify
, 0, "idle", 0);
3551 if (sc
->ciss_flags
& CISS_FLAG_THREAD_SHUT
)
3554 cr
= ciss_dequeue_notify(sc
);
3559 cn
= (struct ciss_notify
*)cr
->cr_data
;
3561 switch (cn
->class) {
3562 case CISS_NOTIFY_HOTPLUG
:
3563 ciss_notify_hotplug(sc
, cn
);
3565 case CISS_NOTIFY_LOGICAL
:
3566 ciss_notify_logical(sc
, cn
);
3568 case CISS_NOTIFY_PHYSICAL
:
3569 ciss_notify_physical(sc
, cn
);
3573 ciss_release_request(cr
);
3577 sc
->ciss_notify_thread
= NULL
;
3578 wakeup(&sc
->ciss_notify_thread
);
3584 /************************************************************************
3585 * Start the notification kernel thread.
3588 ciss_spawn_notify_thread(struct ciss_softc
*sc
)
3590 if (kthread_create((void(*)(void *))ciss_notify_thread
, sc
,
3591 &sc
->ciss_notify_thread
, "ciss_notify%d",
3592 device_get_unit(sc
->ciss_dev
)))
3593 panic("Could not create notify thread\n");
3596 /************************************************************************
3597 * Kill the notification kernel thread.
3600 ciss_kill_notify_thread(struct ciss_softc
*sc
)
3603 if (sc
->ciss_notify_thread
== NULL
)
3606 sc
->ciss_flags
|= CISS_FLAG_THREAD_SHUT
;
3607 wakeup(&sc
->ciss_notify
);
3608 tsleep(&sc
->ciss_notify_thread
, 0, "thtrm", 0);
3611 /************************************************************************
3615 ciss_print_request(struct ciss_request
*cr
)
3617 struct ciss_softc
*sc
;
3618 struct ciss_command
*cc
;
3622 cc
= CISS_FIND_COMMAND(cr
);
3624 ciss_printf(sc
, "REQUEST @ %p\n", cr
);
3625 ciss_printf(sc
, " data %p/%d tag %d flags %b\n",
3626 cr
->cr_data
, cr
->cr_length
, cr
->cr_tag
, cr
->cr_flags
,
3627 "\20\1mapped\2sleep\3poll\4dataout\5datain\n");
3628 ciss_printf(sc
, " sg list/total %d/%d host tag 0x%x\n",
3629 cc
->header
.sg_in_list
, cc
->header
.sg_total
, cc
->header
.host_tag
);
3630 switch(cc
->header
.address
.mode
.mode
) {
3631 case CISS_HDR_ADDRESS_MODE_PERIPHERAL
:
3632 case CISS_HDR_ADDRESS_MODE_MASK_PERIPHERAL
:
3633 ciss_printf(sc
, " physical bus %d target %d\n",
3634 cc
->header
.address
.physical
.bus
, cc
->header
.address
.physical
.target
);
3636 case CISS_HDR_ADDRESS_MODE_LOGICAL
:
3637 ciss_printf(sc
, " logical unit %d\n", cc
->header
.address
.logical
.lun
);
3640 ciss_printf(sc
, " %s cdb length %d type %s attribute %s\n",
3641 (cc
->cdb
.direction
== CISS_CDB_DIRECTION_NONE
) ? "no-I/O" :
3642 (cc
->cdb
.direction
== CISS_CDB_DIRECTION_READ
) ? "READ" :
3643 (cc
->cdb
.direction
== CISS_CDB_DIRECTION_WRITE
) ? "WRITE" : "??",
3645 (cc
->cdb
.type
== CISS_CDB_TYPE_COMMAND
) ? "command" :
3646 (cc
->cdb
.type
== CISS_CDB_TYPE_MESSAGE
) ? "message" : "??",
3647 (cc
->cdb
.attribute
== CISS_CDB_ATTRIBUTE_UNTAGGED
) ? "untagged" :
3648 (cc
->cdb
.attribute
== CISS_CDB_ATTRIBUTE_SIMPLE
) ? "simple" :
3649 (cc
->cdb
.attribute
== CISS_CDB_ATTRIBUTE_HEAD_OF_QUEUE
) ? "head-of-queue" :
3650 (cc
->cdb
.attribute
== CISS_CDB_ATTRIBUTE_ORDERED
) ? "ordered" :
3651 (cc
->cdb
.attribute
== CISS_CDB_ATTRIBUTE_AUTO_CONTINGENT
) ? "auto-contingent" : "??");
3652 ciss_printf(sc
, " %*D\n", cc
->cdb
.cdb_length
, &cc
->cdb
.cdb
[0], " ");
3654 if (cc
->header
.host_tag
& CISS_HDR_HOST_TAG_ERROR
) {
3655 /* XXX print error info */
3657 /* since we don't use chained s/g, don't support it here */
3658 for (i
= 0; i
< cc
->header
.sg_in_list
; i
++) {
3660 ciss_printf(sc
, " ");
3661 kprintf("0x%08x/%d ", (u_int32_t
)cc
->sg
[i
].address
, cc
->sg
[i
].length
);
3662 if ((((i
+ 1) % 4) == 0) || (i
== (cc
->header
.sg_in_list
- 1)))
3668 /************************************************************************
3669 * Print information about the status of a logical drive.
3672 ciss_print_ldrive(struct ciss_softc
*sc
, struct ciss_ldrive
*ld
)
3676 if (ld
->cl_lstatus
== NULL
) {
3677 kprintf("does not exist\n");
3681 /* print drive status */
3682 switch(ld
->cl_lstatus
->status
) {
3683 case CISS_LSTATUS_OK
:
3684 kprintf("online\n");
3686 case CISS_LSTATUS_INTERIM_RECOVERY
:
3687 kprintf("in interim recovery mode\n");
3689 case CISS_LSTATUS_READY_RECOVERY
:
3690 kprintf("ready to begin recovery\n");
3692 case CISS_LSTATUS_RECOVERING
:
3693 bus
= CISS_BIG_MAP_BUS(sc
, ld
->cl_lstatus
->drive_rebuilding
);
3694 target
= CISS_BIG_MAP_BUS(sc
, ld
->cl_lstatus
->drive_rebuilding
);
3695 kprintf("being recovered, working on physical drive %d.%d, %u blocks remaining\n",
3696 bus
, target
, ld
->cl_lstatus
->blocks_to_recover
);
3698 case CISS_LSTATUS_EXPANDING
:
3699 kprintf("being expanded, %u blocks remaining\n",
3700 ld
->cl_lstatus
->blocks_to_recover
);
3702 case CISS_LSTATUS_QUEUED_FOR_EXPANSION
:
3703 kprintf("queued for expansion\n");
3705 case CISS_LSTATUS_FAILED
:
3706 kprintf("queued for expansion\n");
3708 case CISS_LSTATUS_WRONG_PDRIVE
:
3709 kprintf("wrong physical drive inserted\n");
3711 case CISS_LSTATUS_MISSING_PDRIVE
:
3712 kprintf("missing a needed physical drive\n");
3714 case CISS_LSTATUS_BECOMING_READY
:
3715 kprintf("becoming ready\n");
3719 /* print failed physical drives */
3720 for (i
= 0; i
< CISS_BIG_MAP_ENTRIES
/ 8; i
++) {
3721 bus
= CISS_BIG_MAP_BUS(sc
, ld
->cl_lstatus
->drive_failure_map
[i
]);
3722 target
= CISS_BIG_MAP_TARGET(sc
, ld
->cl_lstatus
->drive_failure_map
[i
]);
3725 ciss_printf(sc
, "physical drive %d:%d (%x) failed\n", bus
, target
,
3726 ld
->cl_lstatus
->drive_failure_map
[i
]);
3731 /************************************************************************
3732 * Print information about the controller/driver.
3735 ciss_print_adapter(struct ciss_softc
*sc
)
3739 ciss_printf(sc
, "ADAPTER:\n");
3740 for (i
= 0; i
< CISSQ_COUNT
; i
++) {
3741 ciss_printf(sc
, "%s %d/%d\n",
3743 i
== 1 ? "busy" : "complete",
3744 sc
->ciss_qstat
[i
].q_length
,
3745 sc
->ciss_qstat
[i
].q_max
);
3747 ciss_printf(sc
, "max_requests %d\n", sc
->ciss_max_requests
);
3748 ciss_printf(sc
, "flags %b\n", sc
->ciss_flags
,
3749 "\20\1notify_ok\2control_open\3aborting\4running\21fake_synch\22bmic_abort\n");
3751 for (i
= 0; i
< sc
->ciss_max_logical_bus
; i
++) {
3752 for (j
= 0; j
< CISS_MAX_LOGICAL
; j
++) {
3753 ciss_printf(sc
, "LOGICAL DRIVE %d: ", i
);
3754 ciss_print_ldrive(sc
, &sc
->ciss_logical
[i
][j
]);
3758 /* XXX Should physical drives be printed out here? */
3760 for (i
= 1; i
< sc
->ciss_max_requests
; i
++)
3761 ciss_print_request(sc
->ciss_request
+ i
);
3768 struct ciss_softc
*sc
;
3770 sc
= devclass_get_softc(devclass_find("ciss"), 0);
3772 kprintf("no ciss controllers\n");
3774 ciss_print_adapter(sc
);
3779 /************************************************************************
3780 * Return a name for a logical drive status value.
3783 ciss_name_ldrive_status(int status
)
3786 case CISS_LSTATUS_OK
:
3788 case CISS_LSTATUS_FAILED
:
3790 case CISS_LSTATUS_NOT_CONFIGURED
:
3791 return("not configured");
3792 case CISS_LSTATUS_INTERIM_RECOVERY
:
3793 return("interim recovery");
3794 case CISS_LSTATUS_READY_RECOVERY
:
3795 return("ready for recovery");
3796 case CISS_LSTATUS_RECOVERING
:
3797 return("recovering");
3798 case CISS_LSTATUS_WRONG_PDRIVE
:
3799 return("wrong physical drive inserted");
3800 case CISS_LSTATUS_MISSING_PDRIVE
:
3801 return("missing physical drive");
3802 case CISS_LSTATUS_EXPANDING
:
3803 return("expanding");
3804 case CISS_LSTATUS_BECOMING_READY
:
3805 return("becoming ready");
3806 case CISS_LSTATUS_QUEUED_FOR_EXPANSION
:
3807 return("queued for expansion");
3809 return("unknown status");
3812 /************************************************************************
3813 * Return an online/offline/nonexistent value for a logical drive
3817 ciss_decode_ldrive_status(int status
)
3820 case CISS_LSTATUS_NOT_CONFIGURED
:
3821 return(CISS_LD_NONEXISTENT
);
3823 case CISS_LSTATUS_OK
:
3824 case CISS_LSTATUS_INTERIM_RECOVERY
:
3825 case CISS_LSTATUS_READY_RECOVERY
:
3826 case CISS_LSTATUS_RECOVERING
:
3827 case CISS_LSTATUS_EXPANDING
:
3828 case CISS_LSTATUS_QUEUED_FOR_EXPANSION
:
3829 return(CISS_LD_ONLINE
);
3831 case CISS_LSTATUS_FAILED
:
3832 case CISS_LSTATUS_WRONG_PDRIVE
:
3833 case CISS_LSTATUS_MISSING_PDRIVE
:
3834 case CISS_LSTATUS_BECOMING_READY
:
3836 return(CISS_LD_OFFLINE
);
3841 /************************************************************************
3842 * Return a name for a logical drive's organisation.
3845 ciss_name_ldrive_org(int org
)
3848 case CISS_LDRIVE_RAID0
:
3850 case CISS_LDRIVE_RAID1
:
3852 case CISS_LDRIVE_RAID4
:
3854 case CISS_LDRIVE_RAID5
:
3856 case CISS_LDRIVE_RAID51
:
3858 case CISS_LDRIVE_RAIDADG
:
3864 /************************************************************************
3865 * Return a name for a command status value.
3868 ciss_name_command_status(int status
)
3871 case CISS_CMD_STATUS_SUCCESS
:
3873 case CISS_CMD_STATUS_TARGET_STATUS
:
3874 return("target status");
3875 case CISS_CMD_STATUS_DATA_UNDERRUN
:
3876 return("data underrun");
3877 case CISS_CMD_STATUS_DATA_OVERRUN
:
3878 return("data overrun");
3879 case CISS_CMD_STATUS_INVALID_COMMAND
:
3880 return("invalid command");
3881 case CISS_CMD_STATUS_PROTOCOL_ERROR
:
3882 return("protocol error");
3883 case CISS_CMD_STATUS_HARDWARE_ERROR
:
3884 return("hardware error");
3885 case CISS_CMD_STATUS_CONNECTION_LOST
:
3886 return("connection lost");
3887 case CISS_CMD_STATUS_ABORTED
:
3889 case CISS_CMD_STATUS_ABORT_FAILED
:
3890 return("abort failed");
3891 case CISS_CMD_STATUS_UNSOLICITED_ABORT
:
3892 return("unsolicited abort");
3893 case CISS_CMD_STATUS_TIMEOUT
:
3895 case CISS_CMD_STATUS_UNABORTABLE
:
3896 return("unabortable");
3898 return("unknown status");
3901 /************************************************************************
3902 * Handle an open on the control device.
3905 ciss_open(struct dev_open_args
*ap
)
3907 cdev_t dev
= ap
->a_head
.a_dev
;
3908 struct ciss_softc
*sc
;
3912 sc
= (struct ciss_softc
*)dev
->si_drv1
;
3914 /* we might want to veto if someone already has us open */
3916 sc
->ciss_flags
|= CISS_FLAG_CONTROL_OPEN
;
3920 /************************************************************************
3921 * Handle the last close on the control device.
3924 ciss_close(struct dev_close_args
*ap
)
3926 cdev_t dev
= ap
->a_head
.a_dev
;
3927 struct ciss_softc
*sc
;
3931 sc
= (struct ciss_softc
*)dev
->si_drv1
;
3933 sc
->ciss_flags
&= ~CISS_FLAG_CONTROL_OPEN
;
3937 /********************************************************************************
3938 * Handle adapter-specific control operations.
3940 * Note that the API here is compatible with the Linux driver, in order to
3941 * simplify the porting of Compaq's userland tools.
3944 ciss_ioctl(struct dev_ioctl_args
*ap
)
3946 cdev_t dev
= ap
->a_head
.a_dev
;
3947 struct ciss_softc
*sc
;
3952 sc
= (struct ciss_softc
*)dev
->si_drv1
;
3956 case CCISS_GETPCIINFO
:
3958 cciss_pci_info_struct
*pis
= (cciss_pci_info_struct
*)ap
->a_data
;
3960 pis
->bus
= pci_get_bus(sc
->ciss_dev
);
3961 pis
->dev_fn
= pci_get_slot(sc
->ciss_dev
);
3962 pis
->board_id
= pci_get_devid(sc
->ciss_dev
);
3967 case CCISS_GETINTINFO
:
3969 cciss_coalint_struct
*cis
= (cciss_coalint_struct
*)ap
->a_data
;
3971 cis
->delay
= sc
->ciss_cfg
->interrupt_coalesce_delay
;
3972 cis
->count
= sc
->ciss_cfg
->interrupt_coalesce_count
;
3977 case CCISS_SETINTINFO
:
3979 cciss_coalint_struct
*cis
= (cciss_coalint_struct
*)ap
->a_data
;
3981 if ((cis
->delay
== 0) && (cis
->count
== 0)) {
3987 * XXX apparently this is only safe if the controller is idle,
3988 * we should suspend it before doing this.
3990 sc
->ciss_cfg
->interrupt_coalesce_delay
= cis
->delay
;
3991 sc
->ciss_cfg
->interrupt_coalesce_count
= cis
->count
;
3993 if (ciss_update_config(sc
))
3996 /* XXX resume the controller here */
4000 case CCISS_GETNODENAME
:
4001 bcopy(sc
->ciss_cfg
->server_name
, (NodeName_type
*)ap
->a_data
,
4002 sizeof(NodeName_type
));
4005 case CCISS_SETNODENAME
:
4006 bcopy((NodeName_type
*)ap
->a_data
, sc
->ciss_cfg
->server_name
,
4007 sizeof(NodeName_type
));
4008 if (ciss_update_config(sc
))
4012 case CCISS_GETHEARTBEAT
:
4013 *(Heartbeat_type
*)ap
->a_data
= sc
->ciss_cfg
->heartbeat
;
4016 case CCISS_GETBUSTYPES
:
4017 *(BusTypes_type
*)ap
->a_data
= sc
->ciss_cfg
->bus_types
;
4020 case CCISS_GETFIRMVER
:
4021 bcopy(sc
->ciss_id
->running_firmware_revision
, (FirmwareVer_type
*)ap
->a_data
,
4022 sizeof(FirmwareVer_type
));
4025 case CCISS_GETDRIVERVER
:
4026 *(DriverVer_type
*)ap
->a_data
= CISS_DRIVER_VERSION
;
4029 case CCISS_REVALIDVOLS
:
4031 * This is a bit ugly; to do it "right" we really need
4032 * to find any disks that have changed, kick CAM off them,
4033 * then rescan only these disks. It'd be nice if they
4034 * a) told us which disk(s) they were going to play with,
4035 * and b) which ones had arrived. 8(
4039 case CCISS_PASSTHRU
:
4040 error
= ciss_user_command(sc
, (IOCTL_Command_struct
*)ap
->a_data
);
4044 debug(0, "unknown ioctl 0x%lx", ap
->a_cmd
);
4046 debug(1, "CCISS_GETPCIINFO: 0x%lx", CCISS_GETPCIINFO
);
4047 debug(1, "CCISS_GETINTINFO: 0x%lx", CCISS_GETINTINFO
);
4048 debug(1, "CCISS_SETINTINFO: 0x%lx", CCISS_SETINTINFO
);
4049 debug(1, "CCISS_GETNODENAME: 0x%lx", CCISS_GETNODENAME
);
4050 debug(1, "CCISS_SETNODENAME: 0x%lx", CCISS_SETNODENAME
);
4051 debug(1, "CCISS_GETHEARTBEAT: 0x%lx", CCISS_GETHEARTBEAT
);
4052 debug(1, "CCISS_GETBUSTYPES: 0x%lx", CCISS_GETBUSTYPES
);
4053 debug(1, "CCISS_GETFIRMVER: 0x%lx", CCISS_GETFIRMVER
);
4054 debug(1, "CCISS_GETDRIVERVER: 0x%lx", CCISS_GETDRIVERVER
);
4055 debug(1, "CCISS_REVALIDVOLS: 0x%lx", CCISS_REVALIDVOLS
);
4056 debug(1, "CCISS_PASSTHRU: 0x%lx", CCISS_PASSTHRU
);