xref: /freebsd/sys/dev/ciss/ciss.c (revision 5f8cb13cfb0c91a4ec1a9648a3ae245b1dff36f6)
13a31b7ebSMike Smith /*-
2718cf2ccSPedro F. Giffuni  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3718cf2ccSPedro F. Giffuni  *
43a31b7ebSMike Smith  * Copyright (c) 2001 Michael Smith
5c6131460SPaul Saab  * Copyright (c) 2004 Paul Saab
63a31b7ebSMike Smith  * All rights reserved.
73a31b7ebSMike Smith  *
83a31b7ebSMike Smith  * Redistribution and use in source and binary forms, with or without
93a31b7ebSMike Smith  * modification, are permitted provided that the following conditions
103a31b7ebSMike Smith  * are met:
113a31b7ebSMike Smith  * 1. Redistributions of source code must retain the above copyright
123a31b7ebSMike Smith  *    notice, this list of conditions and the following disclaimer.
133a31b7ebSMike Smith  * 2. Redistributions in binary form must reproduce the above copyright
143a31b7ebSMike Smith  *    notice, this list of conditions and the following disclaimer in the
153a31b7ebSMike Smith  *    documentation and/or other materials provided with the distribution.
163a31b7ebSMike Smith  *
173a31b7ebSMike Smith  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
183a31b7ebSMike Smith  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
193a31b7ebSMike Smith  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
203a31b7ebSMike Smith  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
213a31b7ebSMike Smith  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
223a31b7ebSMike Smith  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
233a31b7ebSMike Smith  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
243a31b7ebSMike Smith  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
253a31b7ebSMike Smith  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
263a31b7ebSMike Smith  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
273a31b7ebSMike Smith  * SUCH DAMAGE.
283a31b7ebSMike Smith  *
293a31b7ebSMike Smith  *	$FreeBSD$
303a31b7ebSMike Smith  */
313a31b7ebSMike Smith 
323a31b7ebSMike Smith /*
333a31b7ebSMike Smith  * Common Interface for SCSI-3 Support driver.
343a31b7ebSMike Smith  *
353a31b7ebSMike Smith  * CISS claims to provide a common interface between a generic SCSI
363a31b7ebSMike Smith  * transport and an intelligent host adapter.
373a31b7ebSMike Smith  *
383a31b7ebSMike Smith  * This driver supports CISS as defined in the document "CISS Command
393a31b7ebSMike Smith  * Interface for SCSI-3 Support Open Specification", Version 1.04,
403a31b7ebSMike Smith  * Valence Number 1, dated 20001127, produced by Compaq Computer
413a31b7ebSMike Smith  * Corporation.  This document appears to be a hastily and somewhat
423a31b7ebSMike Smith  * arbitrarlily cut-down version of a larger (and probably even more
433a31b7ebSMike Smith  * chaotic and inconsistent) Compaq internal document.  Various
443a31b7ebSMike Smith  * details were also gleaned from Compaq's "cciss" driver for Linux.
453a31b7ebSMike Smith  *
463a31b7ebSMike Smith  * We provide a shim layer between the CISS interface and CAM,
473a31b7ebSMike Smith  * offloading most of the queueing and being-a-disk chores onto CAM.
483a31b7ebSMike Smith  * Entry to the driver is via the PCI bus attachment (ciss_probe,
493a31b7ebSMike Smith  * ciss_attach, etc) and via the CAM interface (ciss_cam_action,
503a31b7ebSMike Smith  * ciss_cam_poll).  The Compaq CISS adapters are, however, poor SCSI
513a31b7ebSMike Smith  * citizens and we have to fake up some responses to get reasonable
523a31b7ebSMike Smith  * behaviour out of them.  In addition, the CISS command set is by no
533a31b7ebSMike Smith  * means adequate to support the functionality of a RAID controller,
543a31b7ebSMike Smith  * and thus the supported Compaq adapters utilise portions of the
553a31b7ebSMike Smith  * control protocol from earlier Compaq adapter families.
563a31b7ebSMike Smith  *
573a31b7ebSMike Smith  * Note that we only support the "simple" transport layer over PCI.
583a31b7ebSMike Smith  * This interface (ab)uses the I2O register set (specifically the post
593a31b7ebSMike Smith  * queues) to exchange commands with the adapter.  Other interfaces
603a31b7ebSMike Smith  * are available, but we aren't supposed to know about them, and it is
613a31b7ebSMike Smith  * dubious whether they would provide major performance improvements
623a31b7ebSMike Smith  * except under extreme load.
633a31b7ebSMike Smith  *
643a31b7ebSMike Smith  * Currently the only supported CISS adapters are the Compaq Smart
653a31b7ebSMike Smith  * Array 5* series (5300, 5i, 532).  Even with only three adapters,
663a31b7ebSMike Smith  * Compaq still manage to have interface variations.
673a31b7ebSMike Smith  *
683a31b7ebSMike Smith  *
693a31b7ebSMike Smith  * Thanks must go to Fred Harris and Darryl DeVinney at Compaq, as
703a31b7ebSMike Smith  * well as Paul Saab at Yahoo! for their assistance in making this
713a31b7ebSMike Smith  * driver happen.
72c6131460SPaul Saab  *
73c6131460SPaul Saab  * More thanks must go to John Cagle at HP for the countless hours
74c6131460SPaul Saab  * spent making this driver "work" with the MSA* series storage
75c6131460SPaul Saab  * enclosures.  Without his help (and nagging), this driver could not
76c6131460SPaul Saab  * be used with these enclosures.
773a31b7ebSMike Smith  */
783a31b7ebSMike Smith 
793a31b7ebSMike Smith #include <sys/param.h>
803a31b7ebSMike Smith #include <sys/systm.h>
813a31b7ebSMike Smith #include <sys/malloc.h>
823a31b7ebSMike Smith #include <sys/kernel.h>
833a31b7ebSMike Smith #include <sys/bus.h>
843a31b7ebSMike Smith #include <sys/conf.h>
853a31b7ebSMike Smith #include <sys/stat.h>
86c6131460SPaul Saab #include <sys/kthread.h>
87c6131460SPaul Saab #include <sys/queue.h>
8817c0792dSPaul Saab #include <sys/sysctl.h>
893a31b7ebSMike Smith 
903a31b7ebSMike Smith #include <cam/cam.h>
913a31b7ebSMike Smith #include <cam/cam_ccb.h>
923a31b7ebSMike Smith #include <cam/cam_periph.h>
933a31b7ebSMike Smith #include <cam/cam_sim.h>
943a31b7ebSMike Smith #include <cam/cam_xpt_sim.h>
953a31b7ebSMike Smith #include <cam/scsi/scsi_all.h>
963a31b7ebSMike Smith #include <cam/scsi/scsi_message.h>
973a31b7ebSMike Smith 
983a31b7ebSMike Smith #include <machine/bus.h>
993a31b7ebSMike Smith #include <machine/endian.h>
1003a31b7ebSMike Smith #include <machine/resource.h>
1013a31b7ebSMike Smith #include <sys/rman.h>
1023a31b7ebSMike Smith 
1034fbd232cSWarner Losh #include <dev/pci/pcireg.h>
1044fbd232cSWarner Losh #include <dev/pci/pcivar.h>
1053a31b7ebSMike Smith 
1063a31b7ebSMike Smith #include <dev/ciss/cissreg.h>
1073a31b7ebSMike Smith #include <dev/ciss/cissio.h>
10822657ce1SScott Long #include <dev/ciss/cissvar.h>
1093a31b7ebSMike Smith 
1102e3d6d0fSWarner Losh #ifdef CISS_DEBUG
1112e3d6d0fSWarner Losh #include "opt_ddb.h"
1122e3d6d0fSWarner Losh #endif
1132e3d6d0fSWarner Losh 
114d745c852SEd Schouten static MALLOC_DEFINE(CISS_MALLOC_CLASS, "ciss_data",
115d745c852SEd Schouten     "ciss internal data buffers");
1163a31b7ebSMike Smith 
1173a31b7ebSMike Smith /* pci interface */
1183a31b7ebSMike Smith static int	ciss_lookup(device_t dev);
1193a31b7ebSMike Smith static int	ciss_probe(device_t dev);
1203a31b7ebSMike Smith static int	ciss_attach(device_t dev);
1213a31b7ebSMike Smith static int	ciss_detach(device_t dev);
1223a31b7ebSMike Smith static int	ciss_shutdown(device_t dev);
1233a31b7ebSMike Smith 
1243a31b7ebSMike Smith /* (de)initialisation functions, control wrappers */
1253a31b7ebSMike Smith static int	ciss_init_pci(struct ciss_softc *sc);
12622657ce1SScott Long static int	ciss_setup_msix(struct ciss_softc *sc);
12722657ce1SScott Long static int	ciss_init_perf(struct ciss_softc *sc);
1283a31b7ebSMike Smith static int	ciss_wait_adapter(struct ciss_softc *sc);
1293a31b7ebSMike Smith static int	ciss_flush_adapter(struct ciss_softc *sc);
1303a31b7ebSMike Smith static int	ciss_init_requests(struct ciss_softc *sc);
1313a31b7ebSMike Smith static void	ciss_command_map_helper(void *arg, bus_dma_segment_t *segs,
1323a31b7ebSMike Smith 					int nseg, int error);
1333a31b7ebSMike Smith static int	ciss_identify_adapter(struct ciss_softc *sc);
1343a31b7ebSMike Smith static int	ciss_init_logical(struct ciss_softc *sc);
135c6131460SPaul Saab static int	ciss_init_physical(struct ciss_softc *sc);
1361fe6c4eeSScott Long static int	ciss_filter_physical(struct ciss_softc *sc, struct ciss_lun_report *cll);
1373a31b7ebSMike Smith static int	ciss_identify_logical(struct ciss_softc *sc, struct ciss_ldrive *ld);
1383a31b7ebSMike Smith static int	ciss_get_ldrive_status(struct ciss_softc *sc,  struct ciss_ldrive *ld);
1393a31b7ebSMike Smith static int	ciss_update_config(struct ciss_softc *sc);
14088c78a38SPaul Saab static int	ciss_accept_media(struct ciss_softc *sc, struct ciss_ldrive *ld);
14117c0792dSPaul Saab static void	ciss_init_sysctl(struct ciss_softc *sc);
14217c0792dSPaul Saab static void	ciss_soft_reset(struct ciss_softc *sc);
1433a31b7ebSMike Smith static void	ciss_free(struct ciss_softc *sc);
144c6131460SPaul Saab static void	ciss_spawn_notify_thread(struct ciss_softc *sc);
145c6131460SPaul Saab static void	ciss_kill_notify_thread(struct ciss_softc *sc);
1463a31b7ebSMike Smith 
1473a31b7ebSMike Smith /* request submission/completion */
1483a31b7ebSMike Smith static int	ciss_start(struct ciss_request *cr);
14922657ce1SScott Long static void	ciss_done(struct ciss_softc *sc, cr_qhead_t *qh);
15022657ce1SScott Long static void	ciss_perf_done(struct ciss_softc *sc, cr_qhead_t *qh);
1513a31b7ebSMike Smith static void	ciss_intr(void *arg);
15222657ce1SScott Long static void	ciss_perf_intr(void *arg);
15322657ce1SScott Long static void	ciss_perf_msi_intr(void *arg);
15422657ce1SScott Long static void	ciss_complete(struct ciss_softc *sc, cr_qhead_t *qh);
15522657ce1SScott Long static int	_ciss_report_request(struct ciss_request *cr, int *command_status, int *scsi_status, const char *func);
1563a31b7ebSMike Smith static int	ciss_synch_request(struct ciss_request *cr, int timeout);
1573a31b7ebSMike Smith static int	ciss_poll_request(struct ciss_request *cr, int timeout);
1583a31b7ebSMike Smith static int	ciss_wait_request(struct ciss_request *cr, int timeout);
1596197ca15SPeter Wemm #if 0
1603a31b7ebSMike Smith static int	ciss_abort_request(struct ciss_request *cr);
1616197ca15SPeter Wemm #endif
1623a31b7ebSMike Smith 
1633a31b7ebSMike Smith /* request queueing */
1643a31b7ebSMike Smith static int	ciss_get_request(struct ciss_softc *sc, struct ciss_request **crp);
1653a31b7ebSMike Smith static void	ciss_preen_command(struct ciss_request *cr);
1663a31b7ebSMike Smith static void 	ciss_release_request(struct ciss_request *cr);
1673a31b7ebSMike Smith 
1683a31b7ebSMike Smith /* request helpers */
1693a31b7ebSMike Smith static int	ciss_get_bmic_request(struct ciss_softc *sc, struct ciss_request **crp,
1703a31b7ebSMike Smith 				      int opcode, void **bufp, size_t bufsize);
1713a31b7ebSMike Smith static int	ciss_user_command(struct ciss_softc *sc, IOCTL_Command_struct *ioc);
1723a31b7ebSMike Smith 
1733a31b7ebSMike Smith /* DMA map/unmap */
1743a31b7ebSMike Smith static int	ciss_map_request(struct ciss_request *cr);
1753a31b7ebSMike Smith static void	ciss_request_map_helper(void *arg, bus_dma_segment_t *segs,
1763a31b7ebSMike Smith 					int nseg, int error);
1773a31b7ebSMike Smith static void	ciss_unmap_request(struct ciss_request *cr);
1783a31b7ebSMike Smith 
1793a31b7ebSMike Smith /* CAM interface */
1803a31b7ebSMike Smith static int	ciss_cam_init(struct ciss_softc *sc);
181c6131460SPaul Saab static void	ciss_cam_rescan_target(struct ciss_softc *sc,
182c6131460SPaul Saab 				       int bus, int target);
1833a31b7ebSMike Smith static void	ciss_cam_action(struct cam_sim *sim, union ccb *ccb);
1843a31b7ebSMike Smith static int	ciss_cam_action_io(struct cam_sim *sim, struct ccb_scsiio *csio);
1853a31b7ebSMike Smith static int	ciss_cam_emulate(struct ciss_softc *sc, struct ccb_scsiio *csio);
1863a31b7ebSMike Smith static void	ciss_cam_poll(struct cam_sim *sim);
1873a31b7ebSMike Smith static void	ciss_cam_complete(struct ciss_request *cr);
1883a31b7ebSMike Smith static void	ciss_cam_complete_fixup(struct ciss_softc *sc, struct ccb_scsiio *csio);
189c6131460SPaul Saab static int	ciss_name_device(struct ciss_softc *sc, int bus, int target);
1903a31b7ebSMike Smith 
1913a31b7ebSMike Smith /* periodic status monitoring */
1923a31b7ebSMike Smith static void	ciss_periodic(void *arg);
19354d02e0aSMitsuru IWASAKI static void	ciss_nop_complete(struct ciss_request *cr);
194e08d902aSMitsuru IWASAKI static void	ciss_disable_adapter(struct ciss_softc *sc);
1953a31b7ebSMike Smith static void	ciss_notify_event(struct ciss_softc *sc);
1963a31b7ebSMike Smith static void	ciss_notify_complete(struct ciss_request *cr);
1973a31b7ebSMike Smith static int	ciss_notify_abort(struct ciss_softc *sc);
1983a31b7ebSMike Smith static int	ciss_notify_abort_bmic(struct ciss_softc *sc);
1991fe6c4eeSScott Long static void	ciss_notify_hotplug(struct ciss_softc *sc, struct ciss_notify *cn);
2003a31b7ebSMike Smith static void	ciss_notify_logical(struct ciss_softc *sc, struct ciss_notify *cn);
2013a31b7ebSMike Smith static void	ciss_notify_physical(struct ciss_softc *sc, struct ciss_notify *cn);
2023a31b7ebSMike Smith 
2033a31b7ebSMike Smith /* debugging output */
2042e3d6d0fSWarner Losh #ifdef DDB
2053a31b7ebSMike Smith static void	ciss_print_request(struct ciss_request *cr);
2062e3d6d0fSWarner Losh #endif
2073a31b7ebSMike Smith static void	ciss_print_ldrive(struct ciss_softc *sc, struct ciss_ldrive *ld);
2083a31b7ebSMike Smith static const char *ciss_name_ldrive_status(int status);
2093a31b7ebSMike Smith static int	ciss_decode_ldrive_status(int status);
2103a31b7ebSMike Smith static const char *ciss_name_ldrive_org(int org);
2113a31b7ebSMike Smith static const char *ciss_name_command_status(int status);
2123a31b7ebSMike Smith 
2133a31b7ebSMike Smith /*
2143a31b7ebSMike Smith  * PCI bus interface.
2153a31b7ebSMike Smith  */
2163a31b7ebSMike Smith static device_method_t ciss_methods[] = {
2173a31b7ebSMike Smith     /* Device interface */
2183a31b7ebSMike Smith     DEVMETHOD(device_probe,	ciss_probe),
2193a31b7ebSMike Smith     DEVMETHOD(device_attach,	ciss_attach),
2203a31b7ebSMike Smith     DEVMETHOD(device_detach,	ciss_detach),
2213a31b7ebSMike Smith     DEVMETHOD(device_shutdown,	ciss_shutdown),
2223a31b7ebSMike Smith     { 0, 0 }
2233a31b7ebSMike Smith };
2243a31b7ebSMike Smith 
2253a31b7ebSMike Smith static driver_t ciss_pci_driver = {
2263a31b7ebSMike Smith     "ciss",
2273a31b7ebSMike Smith     ciss_methods,
2283a31b7ebSMike Smith     sizeof(struct ciss_softc)
2293a31b7ebSMike Smith };
2303a31b7ebSMike Smith 
2313a31b7ebSMike Smith /*
2323a31b7ebSMike Smith  * Control device interface.
2333a31b7ebSMike Smith  */
2343a31b7ebSMike Smith static d_open_t		ciss_open;
2353a31b7ebSMike Smith static d_close_t	ciss_close;
2363a31b7ebSMike Smith static d_ioctl_t	ciss_ioctl;
2373a31b7ebSMike Smith 
2383a31b7ebSMike Smith static struct cdevsw ciss_cdevsw = {
239dc08ffecSPoul-Henning Kamp 	.d_version =	D_VERSION,
240975b7318SScott Long 	.d_flags =	0,
2417ac40f5fSPoul-Henning Kamp 	.d_open =	ciss_open,
2427ac40f5fSPoul-Henning Kamp 	.d_close =	ciss_close,
2437ac40f5fSPoul-Henning Kamp 	.d_ioctl =	ciss_ioctl,
2447ac40f5fSPoul-Henning Kamp 	.d_name =	"ciss",
2453a31b7ebSMike Smith };
2463a31b7ebSMike Smith 
2471fe6c4eeSScott Long /*
2481fe6c4eeSScott Long  * This tunable can be set at boot time and controls whether physical devices
2491fe6c4eeSScott Long  * that are marked hidden by the firmware should be exposed anyways.
2501fe6c4eeSScott Long  */
2511fe6c4eeSScott Long static unsigned int ciss_expose_hidden_physical = 0;
2521fe6c4eeSScott Long TUNABLE_INT("hw.ciss.expose_hidden_physical", &ciss_expose_hidden_physical);
2531fe6c4eeSScott Long 
2545a3c4d69SMitsuru IWASAKI static unsigned int ciss_nop_message_heartbeat = 0;
2555a3c4d69SMitsuru IWASAKI TUNABLE_INT("hw.ciss.nop_message_heartbeat", &ciss_nop_message_heartbeat);
2565a3c4d69SMitsuru IWASAKI 
25722657ce1SScott Long /*
25822657ce1SScott Long  * This tunable can force a particular transport to be used:
25922657ce1SScott Long  * <= 0 : use default
26022657ce1SScott Long  *    1 : force simple
26122657ce1SScott Long  *    2 : force performant
26222657ce1SScott Long  */
26322657ce1SScott Long static int ciss_force_transport = 0;
26422657ce1SScott Long TUNABLE_INT("hw.ciss.force_transport", &ciss_force_transport);
26522657ce1SScott Long 
26622657ce1SScott Long /*
26722657ce1SScott Long  * This tunable can force a particular interrupt delivery method to be used:
26822657ce1SScott Long  * <= 0 : use default
26922657ce1SScott Long  *    1 : force INTx
27022657ce1SScott Long  *    2 : force MSIX
27122657ce1SScott Long  */
27222657ce1SScott Long static int ciss_force_interrupt = 0;
27322657ce1SScott Long TUNABLE_INT("hw.ciss.force_interrupt", &ciss_force_interrupt);
27422657ce1SScott Long 
2753a31b7ebSMike Smith /************************************************************************
2763a31b7ebSMike Smith  * CISS adapters amazingly don't have a defined programming interface
2773a31b7ebSMike Smith  * value.  (One could say some very despairing things about PCI and
2783a31b7ebSMike Smith  * people just not getting the general idea.)  So we are forced to
2793a31b7ebSMike Smith  * stick with matching against subvendor/subdevice, and thus have to
2803a31b7ebSMike Smith  * be updated for every new CISS adapter that appears.
2813a31b7ebSMike Smith  */
2822fdaa90dSScott Long #define CISS_BOARD_UNKNWON	0
2832fdaa90dSScott Long #define CISS_BOARD_SA5		1
2842fdaa90dSScott Long #define CISS_BOARD_SA5B		2
2852fdaa90dSScott Long #define CISS_BOARD_NOMSI	(1<<4)
286ee4827b2SSean Bruno #define CISS_BOARD_SIMPLE       (1<<5)
2873a31b7ebSMike Smith 
2883a31b7ebSMike Smith static struct
2893a31b7ebSMike Smith {
2903a31b7ebSMike Smith     u_int16_t	subvendor;
2913a31b7ebSMike Smith     u_int16_t	subdevice;
2923a31b7ebSMike Smith     int		flags;
2933a31b7ebSMike Smith     char	*desc;
2943a31b7ebSMike Smith } ciss_vendor_data[] = {
295ee4827b2SSean Bruno     { 0x0e11, 0x4070, CISS_BOARD_SA5|CISS_BOARD_NOMSI|CISS_BOARD_SIMPLE,
296ee4827b2SSean Bruno                                                         "Compaq Smart Array 5300" },
2972fdaa90dSScott Long     { 0x0e11, 0x4080, CISS_BOARD_SA5B|CISS_BOARD_NOMSI,	"Compaq Smart Array 5i" },
2982fdaa90dSScott Long     { 0x0e11, 0x4082, CISS_BOARD_SA5B|CISS_BOARD_NOMSI,	"Compaq Smart Array 532" },
2992fdaa90dSScott Long     { 0x0e11, 0x4083, CISS_BOARD_SA5B|CISS_BOARD_NOMSI,	"HP Smart Array 5312" },
300b26392c7SPaul Saab     { 0x0e11, 0x4091, CISS_BOARD_SA5,	"HP Smart Array 6i" },
3019e7313bbSPaul Saab     { 0x0e11, 0x409A, CISS_BOARD_SA5,	"HP Smart Array 641" },
3029e7313bbSPaul Saab     { 0x0e11, 0x409B, CISS_BOARD_SA5,	"HP Smart Array 642" },
3039e7313bbSPaul Saab     { 0x0e11, 0x409C, CISS_BOARD_SA5,	"HP Smart Array 6400" },
3049e7313bbSPaul Saab     { 0x0e11, 0x409D, CISS_BOARD_SA5,	"HP Smart Array 6400 EM" },
305cad572c4SPaul Saab     { 0x103C, 0x3211, CISS_BOARD_SA5,	"HP Smart Array E200i" },
306cad572c4SPaul Saab     { 0x103C, 0x3212, CISS_BOARD_SA5,	"HP Smart Array E200" },
307cad572c4SPaul Saab     { 0x103C, 0x3213, CISS_BOARD_SA5,	"HP Smart Array E200i" },
308cad572c4SPaul Saab     { 0x103C, 0x3214, CISS_BOARD_SA5,	"HP Smart Array E200i" },
309cad572c4SPaul Saab     { 0x103C, 0x3215, CISS_BOARD_SA5,	"HP Smart Array E200i" },
310b612d5e1SPaul Saab     { 0x103C, 0x3220, CISS_BOARD_SA5,	"HP Smart Array" },
311b612d5e1SPaul Saab     { 0x103C, 0x3222, CISS_BOARD_SA5,	"HP Smart Array" },
3124bb10cf1SPaul Saab     { 0x103C, 0x3223, CISS_BOARD_SA5,	"HP Smart Array P800" },
313f3f82767SPaul Saab     { 0x103C, 0x3225, CISS_BOARD_SA5,	"HP Smart Array P600" },
314b612d5e1SPaul Saab     { 0x103C, 0x3230, CISS_BOARD_SA5,	"HP Smart Array" },
315cad572c4SPaul Saab     { 0x103C, 0x3231, CISS_BOARD_SA5,	"HP Smart Array" },
316b612d5e1SPaul Saab     { 0x103C, 0x3232, CISS_BOARD_SA5,	"HP Smart Array" },
317b612d5e1SPaul Saab     { 0x103C, 0x3233, CISS_BOARD_SA5,	"HP Smart Array" },
318cad572c4SPaul Saab     { 0x103C, 0x3234, CISS_BOARD_SA5,	"HP Smart Array P400" },
319cad572c4SPaul Saab     { 0x103C, 0x3235, CISS_BOARD_SA5,	"HP Smart Array P400i" },
320b612d5e1SPaul Saab     { 0x103C, 0x3236, CISS_BOARD_SA5,	"HP Smart Array" },
3217b6d3d4cSScott Long     { 0x103C, 0x3237, CISS_BOARD_SA5,	"HP Smart Array E500" },
322b612d5e1SPaul Saab     { 0x103C, 0x3238, CISS_BOARD_SA5,	"HP Smart Array" },
323b612d5e1SPaul Saab     { 0x103C, 0x3239, CISS_BOARD_SA5,	"HP Smart Array" },
324b612d5e1SPaul Saab     { 0x103C, 0x323A, CISS_BOARD_SA5,	"HP Smart Array" },
325b612d5e1SPaul Saab     { 0x103C, 0x323B, CISS_BOARD_SA5,	"HP Smart Array" },
326b612d5e1SPaul Saab     { 0x103C, 0x323C, CISS_BOARD_SA5,	"HP Smart Array" },
3277b6d3d4cSScott Long     { 0x103C, 0x323D, CISS_BOARD_SA5,	"HP Smart Array P700m" },
328160b4e6bSPaul Saab     { 0x103C, 0x3241, CISS_BOARD_SA5,	"HP Smart Array P212" },
329160b4e6bSPaul Saab     { 0x103C, 0x3243, CISS_BOARD_SA5,	"HP Smart Array P410" },
330160b4e6bSPaul Saab     { 0x103C, 0x3245, CISS_BOARD_SA5,	"HP Smart Array P410i" },
331160b4e6bSPaul Saab     { 0x103C, 0x3247, CISS_BOARD_SA5,	"HP Smart Array P411" },
332160b4e6bSPaul Saab     { 0x103C, 0x3249, CISS_BOARD_SA5,	"HP Smart Array P812" },
3337b6d3d4cSScott Long     { 0x103C, 0x324A, CISS_BOARD_SA5,	"HP Smart Array P712m" },
3347b6d3d4cSScott Long     { 0x103C, 0x324B, CISS_BOARD_SA5,	"HP Smart Array" },
335e17ef005SSean Bruno     { 0x103C, 0x3350, CISS_BOARD_SA5,   "HP Smart Array P222" },
3365564c1cdSSean Bruno     { 0x103C, 0x3351, CISS_BOARD_SA5,   "HP Smart Array P420" },
337e17ef005SSean Bruno     { 0x103C, 0x3352, CISS_BOARD_SA5,   "HP Smart Array P421" },
338e17ef005SSean Bruno     { 0x103C, 0x3353, CISS_BOARD_SA5,   "HP Smart Array P822" },
339e17ef005SSean Bruno     { 0x103C, 0x3354, CISS_BOARD_SA5,   "HP Smart Array P420i" },
340e17ef005SSean Bruno     { 0x103C, 0x3355, CISS_BOARD_SA5,   "HP Smart Array P220i" },
341e17ef005SSean Bruno     { 0x103C, 0x3356, CISS_BOARD_SA5,   "HP Smart Array P721m" },
342ec5d9810SSean Bruno     { 0x103C, 0x1920, CISS_BOARD_SA5,   "HP Smart Array P430i" },
343ec5d9810SSean Bruno     { 0x103C, 0x1921, CISS_BOARD_SA5,   "HP Smart Array P830i" },
344ec5d9810SSean Bruno     { 0x103C, 0x1922, CISS_BOARD_SA5,   "HP Smart Array P430" },
345ec5d9810SSean Bruno     { 0x103C, 0x1923, CISS_BOARD_SA5,   "HP Smart Array P431" },
346ec5d9810SSean Bruno     { 0x103C, 0x1924, CISS_BOARD_SA5,   "HP Smart Array P830" },
347ec5d9810SSean Bruno     { 0x103C, 0x1926, CISS_BOARD_SA5,   "HP Smart Array P731m" },
348ec5d9810SSean Bruno     { 0x103C, 0x1928, CISS_BOARD_SA5,   "HP Smart Array P230i" },
349ec5d9810SSean Bruno     { 0x103C, 0x1929, CISS_BOARD_SA5,   "HP Smart Array P530" },
350ec5d9810SSean Bruno     { 0x103C, 0x192A, CISS_BOARD_SA5,   "HP Smart Array P531" },
351bf10f1a0SSean Bruno     { 0x103C, 0x21BD, CISS_BOARD_SA5,   "HP Smart Array P244br" },
352bf10f1a0SSean Bruno     { 0x103C, 0x21BE, CISS_BOARD_SA5,   "HP Smart Array P741m" },
353bf10f1a0SSean Bruno     { 0x103C, 0x21BF, CISS_BOARD_SA5,   "HP Smart Array H240ar" },
354bf10f1a0SSean Bruno     { 0x103C, 0x21C0, CISS_BOARD_SA5,   "HP Smart Array P440ar" },
355bf10f1a0SSean Bruno     { 0x103C, 0x21C1, CISS_BOARD_SA5,   "HP Smart Array P840ar" },
356bf10f1a0SSean Bruno     { 0x103C, 0x21C2, CISS_BOARD_SA5,   "HP Smart Array P440" },
357bf10f1a0SSean Bruno     { 0x103C, 0x21C3, CISS_BOARD_SA5,   "HP Smart Array P441" },
358bf10f1a0SSean Bruno     { 0x103C, 0x21C5, CISS_BOARD_SA5,   "HP Smart Array P841" },
359bf10f1a0SSean Bruno     { 0x103C, 0x21C6, CISS_BOARD_SA5,   "HP Smart Array H244br" },
360bf10f1a0SSean Bruno     { 0x103C, 0x21C7, CISS_BOARD_SA5,   "HP Smart Array H240" },
361bf10f1a0SSean Bruno     { 0x103C, 0x21C8, CISS_BOARD_SA5,   "HP Smart Array H241" },
362bf10f1a0SSean Bruno     { 0x103C, 0x21CA, CISS_BOARD_SA5,   "HP Smart Array P246br" },
363bf10f1a0SSean Bruno     { 0x103C, 0x21CB, CISS_BOARD_SA5,   "HP Smart Array P840" },
364d3d9a343SScott Long     { 0x103C, 0x21CC, CISS_BOARD_SA5,   "HP Smart Array P542d" },
365bf10f1a0SSean Bruno     { 0x103C, 0x21CD, CISS_BOARD_SA5,   "HP Smart Array P240nr" },
366bf10f1a0SSean Bruno     { 0x103C, 0x21CE, CISS_BOARD_SA5,   "HP Smart Array H240nr" },
3674a6a94d8SArchie Cobbs     { 0, 0, 0, NULL }
3683a31b7ebSMike Smith };
3693a31b7ebSMike Smith 
3704322d107SWarner Losh static devclass_t	ciss_devclass;
3714322d107SWarner Losh DRIVER_MODULE(ciss, pci, ciss_pci_driver, ciss_devclass, 0, 0);
3724322d107SWarner Losh MODULE_PNP_INFO("U16:vendor;U16:device;", pci, ciss, ciss_vendor_data,
373329e817fSWarner Losh     nitems(ciss_vendor_data) - 1);
3744322d107SWarner Losh MODULE_DEPEND(ciss, cam, 1, 1, 1);
3754322d107SWarner Losh MODULE_DEPEND(ciss, pci, 1, 1, 1);
3764322d107SWarner Losh 
3773a31b7ebSMike Smith /************************************************************************
3783a31b7ebSMike Smith  * Find a match for the device in our list of known adapters.
3793a31b7ebSMike Smith  */
3803a31b7ebSMike Smith static int
3813a31b7ebSMike Smith ciss_lookup(device_t dev)
3823a31b7ebSMike Smith {
3833a31b7ebSMike Smith     int 	i;
3843a31b7ebSMike Smith 
3853a31b7ebSMike Smith     for (i = 0; ciss_vendor_data[i].desc != NULL; i++)
3863a31b7ebSMike Smith 	if ((pci_get_subvendor(dev) == ciss_vendor_data[i].subvendor) &&
3873a31b7ebSMike Smith 	    (pci_get_subdevice(dev) == ciss_vendor_data[i].subdevice)) {
3883a31b7ebSMike Smith 	    return(i);
3893a31b7ebSMike Smith 	}
3903a31b7ebSMike Smith     return(-1);
3913a31b7ebSMike Smith }
3923a31b7ebSMike Smith 
3933a31b7ebSMike Smith /************************************************************************
3943a31b7ebSMike Smith  * Match a known CISS adapter.
3953a31b7ebSMike Smith  */
3963a31b7ebSMike Smith static int
3973a31b7ebSMike Smith ciss_probe(device_t dev)
3983a31b7ebSMike Smith {
3993a31b7ebSMike Smith     int		i;
4003a31b7ebSMike Smith 
4013a31b7ebSMike Smith     i = ciss_lookup(dev);
4023a31b7ebSMike Smith     if (i != -1) {
4033a31b7ebSMike Smith 	device_set_desc(dev, ciss_vendor_data[i].desc);
404538565c4SWarner Losh 	return(BUS_PROBE_DEFAULT);
4053a31b7ebSMike Smith     }
4063a31b7ebSMike Smith     return(ENOENT);
4073a31b7ebSMike Smith }
4083a31b7ebSMike Smith 
4093a31b7ebSMike Smith /************************************************************************
4103a31b7ebSMike Smith  * Attach the driver to this adapter.
4113a31b7ebSMike Smith  */
4123a31b7ebSMike Smith static int
4133a31b7ebSMike Smith ciss_attach(device_t dev)
4143a31b7ebSMike Smith {
4153a31b7ebSMike Smith     struct ciss_softc	*sc;
416d69c9c78SScott Long     int			error;
4173a31b7ebSMike Smith 
4183a31b7ebSMike Smith     debug_called(1);
4193a31b7ebSMike Smith 
4203a31b7ebSMike Smith #ifdef CISS_DEBUG
4213a31b7ebSMike Smith     /* print structure/union sizes */
4223a31b7ebSMike Smith     debug_struct(ciss_command);
4233a31b7ebSMike Smith     debug_struct(ciss_header);
4243a31b7ebSMike Smith     debug_union(ciss_device_address);
4253a31b7ebSMike Smith     debug_struct(ciss_cdb);
4263a31b7ebSMike Smith     debug_struct(ciss_report_cdb);
4273a31b7ebSMike Smith     debug_struct(ciss_notify_cdb);
4283a31b7ebSMike Smith     debug_struct(ciss_notify);
4293a31b7ebSMike Smith     debug_struct(ciss_message_cdb);
4303a31b7ebSMike Smith     debug_struct(ciss_error_info_pointer);
4313a31b7ebSMike Smith     debug_struct(ciss_error_info);
4323a31b7ebSMike Smith     debug_struct(ciss_sg_entry);
4333a31b7ebSMike Smith     debug_struct(ciss_config_table);
4343a31b7ebSMike Smith     debug_struct(ciss_bmic_cdb);
4353a31b7ebSMike Smith     debug_struct(ciss_bmic_id_ldrive);
4363a31b7ebSMike Smith     debug_struct(ciss_bmic_id_lstatus);
4373a31b7ebSMike Smith     debug_struct(ciss_bmic_id_table);
4383a31b7ebSMike Smith     debug_struct(ciss_bmic_id_pdrive);
4393a31b7ebSMike Smith     debug_struct(ciss_bmic_blink_pdrive);
4403a31b7ebSMike Smith     debug_struct(ciss_bmic_flush_cache);
4413a31b7ebSMike Smith     debug_const(CISS_MAX_REQUESTS);
4423a31b7ebSMike Smith     debug_const(CISS_MAX_LOGICAL);
4433a31b7ebSMike Smith     debug_const(CISS_INTERRUPT_COALESCE_DELAY);
4443a31b7ebSMike Smith     debug_const(CISS_INTERRUPT_COALESCE_COUNT);
4453a31b7ebSMike Smith     debug_const(CISS_COMMAND_ALLOC_SIZE);
4463a31b7ebSMike Smith     debug_const(CISS_COMMAND_SG_LENGTH);
4473a31b7ebSMike Smith 
4483a31b7ebSMike Smith     debug_type(cciss_pci_info_struct);
4493a31b7ebSMike Smith     debug_type(cciss_coalint_struct);
4503a31b7ebSMike Smith     debug_type(cciss_coalint_struct);
4513a31b7ebSMike Smith     debug_type(NodeName_type);
4523a31b7ebSMike Smith     debug_type(NodeName_type);
4533a31b7ebSMike Smith     debug_type(Heartbeat_type);
4543a31b7ebSMike Smith     debug_type(BusTypes_type);
4553a31b7ebSMike Smith     debug_type(FirmwareVer_type);
4563a31b7ebSMike Smith     debug_type(DriverVer_type);
4573a31b7ebSMike Smith     debug_type(IOCTL_Command_struct);
4583a31b7ebSMike Smith #endif
4593a31b7ebSMike Smith 
4603a31b7ebSMike Smith     sc = device_get_softc(dev);
4613a31b7ebSMike Smith     sc->ciss_dev = dev;
46264a026bdSGavin Atkinson     mtx_init(&sc->ciss_mtx, "cissmtx", NULL, MTX_DEF);
463aa1385cdSJohn Baldwin     callout_init_mtx(&sc->ciss_periodic, &sc->ciss_mtx, 0);
4643a31b7ebSMike Smith 
4653a31b7ebSMike Smith     /*
4663a31b7ebSMike Smith      * Do PCI-specific init.
4673a31b7ebSMike Smith      */
4683a31b7ebSMike Smith     if ((error = ciss_init_pci(sc)) != 0)
4693a31b7ebSMike Smith 	goto out;
4703a31b7ebSMike Smith 
4713a31b7ebSMike Smith     /*
4723a31b7ebSMike Smith      * Initialise driver queues.
4733a31b7ebSMike Smith      */
4743a31b7ebSMike Smith     ciss_initq_free(sc);
475c6131460SPaul Saab     ciss_initq_notify(sc);
4763a31b7ebSMike Smith 
4773a31b7ebSMike Smith     /*
478b790c193SPedro F. Giffuni      * Initialize device sysctls.
47917c0792dSPaul Saab      */
48017c0792dSPaul Saab     ciss_init_sysctl(sc);
48117c0792dSPaul Saab 
48217c0792dSPaul Saab     /*
4833a31b7ebSMike Smith      * Initialise command/request pool.
4843a31b7ebSMike Smith      */
4853a31b7ebSMike Smith     if ((error = ciss_init_requests(sc)) != 0)
4863a31b7ebSMike Smith 	goto out;
4873a31b7ebSMike Smith 
4883a31b7ebSMike Smith     /*
4893a31b7ebSMike Smith      * Get adapter information.
4903a31b7ebSMike Smith      */
4913a31b7ebSMike Smith     if ((error = ciss_identify_adapter(sc)) != 0)
4923a31b7ebSMike Smith 	goto out;
4933a31b7ebSMike Smith 
4943a31b7ebSMike Smith     /*
495c6131460SPaul Saab      * Find all the physical devices.
496c6131460SPaul Saab      */
497c6131460SPaul Saab     if ((error = ciss_init_physical(sc)) != 0)
498c6131460SPaul Saab 	goto out;
499c6131460SPaul Saab 
500c6131460SPaul Saab     /*
5013a31b7ebSMike Smith      * Build our private table of logical devices.
5023a31b7ebSMike Smith      */
5033a31b7ebSMike Smith     if ((error = ciss_init_logical(sc)) != 0)
5043a31b7ebSMike Smith 	goto out;
5053a31b7ebSMike Smith 
5063a31b7ebSMike Smith     /*
5073a31b7ebSMike Smith      * Enable interrupts so that the CAM scan can complete.
5083a31b7ebSMike Smith      */
5093a31b7ebSMike Smith     CISS_TL_SIMPLE_ENABLE_INTERRUPTS(sc);
5103a31b7ebSMike Smith 
5113a31b7ebSMike Smith     /*
5123a31b7ebSMike Smith      * Initialise the CAM interface.
5133a31b7ebSMike Smith      */
5143a31b7ebSMike Smith     if ((error = ciss_cam_init(sc)) != 0)
5153a31b7ebSMike Smith 	goto out;
5163a31b7ebSMike Smith 
5173a31b7ebSMike Smith     /*
5183a31b7ebSMike Smith      * Start the heartbeat routine and event chain.
5193a31b7ebSMike Smith      */
5203a31b7ebSMike Smith     ciss_periodic(sc);
5213a31b7ebSMike Smith 
5223a31b7ebSMike Smith    /*
5233a31b7ebSMike Smith      * Create the control device.
5243a31b7ebSMike Smith      */
5253a31b7ebSMike Smith     sc->ciss_dev_t = make_dev(&ciss_cdevsw, device_get_unit(sc->ciss_dev),
5263a31b7ebSMike Smith 			      UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR,
5273a31b7ebSMike Smith 			      "ciss%d", device_get_unit(sc->ciss_dev));
5283a31b7ebSMike Smith     sc->ciss_dev_t->si_drv1 = sc;
5293a31b7ebSMike Smith 
5303a31b7ebSMike Smith     /*
5313a31b7ebSMike Smith      * The adapter is running; synchronous commands can now sleep
5323a31b7ebSMike Smith      * waiting for an interrupt to signal completion.
5333a31b7ebSMike Smith      */
5343a31b7ebSMike Smith     sc->ciss_flags |= CISS_FLAG_RUNNING;
5353a31b7ebSMike Smith 
536c6131460SPaul Saab     ciss_spawn_notify_thread(sc);
537c6131460SPaul Saab 
5383a31b7ebSMike Smith     error = 0;
5393a31b7ebSMike Smith  out:
54064a026bdSGavin Atkinson     if (error != 0) {
54164a026bdSGavin Atkinson 	/* ciss_free() expects the mutex to be held */
54264a026bdSGavin Atkinson 	mtx_lock(&sc->ciss_mtx);
5433a31b7ebSMike Smith 	ciss_free(sc);
54464a026bdSGavin Atkinson     }
5453a31b7ebSMike Smith     return(error);
5463a31b7ebSMike Smith }
5473a31b7ebSMike Smith 
5483a31b7ebSMike Smith /************************************************************************
5493a31b7ebSMike Smith  * Detach the driver from this adapter.
5503a31b7ebSMike Smith  */
5513a31b7ebSMike Smith static int
5523a31b7ebSMike Smith ciss_detach(device_t dev)
5533a31b7ebSMike Smith {
5543a31b7ebSMike Smith     struct ciss_softc	*sc = device_get_softc(dev);
5553a31b7ebSMike Smith 
5563a31b7ebSMike Smith     debug_called(1);
5573a31b7ebSMike Smith 
558975b7318SScott Long     mtx_lock(&sc->ciss_mtx);
559975b7318SScott Long     if (sc->ciss_flags & CISS_FLAG_CONTROL_OPEN) {
560975b7318SScott Long 	mtx_unlock(&sc->ciss_mtx);
561ffdf82e1SPaul Saab 	return (EBUSY);
562975b7318SScott Long     }
563ffdf82e1SPaul Saab 
5643a31b7ebSMike Smith     /* flush adapter cache */
5653a31b7ebSMike Smith     ciss_flush_adapter(sc);
5663a31b7ebSMike Smith 
567975b7318SScott Long     /* release all resources.  The mutex is released and freed here too. */
5683a31b7ebSMike Smith     ciss_free(sc);
5693a31b7ebSMike Smith 
5703a31b7ebSMike Smith     return(0);
5713a31b7ebSMike Smith }
5723a31b7ebSMike Smith 
5733a31b7ebSMike Smith /************************************************************************
5743a31b7ebSMike Smith  * Prepare adapter for system shutdown.
5753a31b7ebSMike Smith  */
5763a31b7ebSMike Smith static int
5773a31b7ebSMike Smith ciss_shutdown(device_t dev)
5783a31b7ebSMike Smith {
5793a31b7ebSMike Smith     struct ciss_softc	*sc = device_get_softc(dev);
5803a31b7ebSMike Smith 
5813a31b7ebSMike Smith     debug_called(1);
5823a31b7ebSMike Smith 
583d4a4ddc6SScott Long     mtx_lock(&sc->ciss_mtx);
5843a31b7ebSMike Smith     /* flush adapter cache */
5853a31b7ebSMike Smith     ciss_flush_adapter(sc);
5863a31b7ebSMike Smith 
58717c0792dSPaul Saab     if (sc->ciss_soft_reset)
58817c0792dSPaul Saab 	ciss_soft_reset(sc);
589d4a4ddc6SScott Long     mtx_unlock(&sc->ciss_mtx);
59017c0792dSPaul Saab 
5913a31b7ebSMike Smith     return(0);
5923a31b7ebSMike Smith }
5933a31b7ebSMike Smith 
59417c0792dSPaul Saab static void
59517c0792dSPaul Saab ciss_init_sysctl(struct ciss_softc *sc)
59617c0792dSPaul Saab {
59717c0792dSPaul Saab 
59817c0792dSPaul Saab     SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->ciss_dev),
59917c0792dSPaul Saab 	SYSCTL_CHILDREN(device_get_sysctl_tree(sc->ciss_dev)),
60017c0792dSPaul Saab 	OID_AUTO, "soft_reset", CTLFLAG_RW, &sc->ciss_soft_reset, 0, "");
60117c0792dSPaul Saab }
60217c0792dSPaul Saab 
6033a31b7ebSMike Smith /************************************************************************
6043a31b7ebSMike Smith  * Perform PCI-specific attachment actions.
6053a31b7ebSMike Smith  */
6063a31b7ebSMike Smith static int
6073a31b7ebSMike Smith ciss_init_pci(struct ciss_softc *sc)
6083a31b7ebSMike Smith {
6093a31b7ebSMike Smith     uintptr_t		cbase, csize, cofs;
61022657ce1SScott Long     uint32_t		method, supported_methods;
611d69c9c78SScott Long     int			error, sqmask, i;
61222657ce1SScott Long     void		*intr;
6133a31b7ebSMike Smith 
6143a31b7ebSMike Smith     debug_called(1);
6153a31b7ebSMike Smith 
6163a31b7ebSMike Smith     /*
617d69c9c78SScott Long      * Work out adapter type.
618d69c9c78SScott Long      */
619d69c9c78SScott Long     i = ciss_lookup(sc->ciss_dev);
620d69c9c78SScott Long     if (i < 0) {
621d69c9c78SScott Long 	ciss_printf(sc, "unknown adapter type\n");
622d69c9c78SScott Long 	return (ENXIO);
623d69c9c78SScott Long     }
624d69c9c78SScott Long 
625d69c9c78SScott Long     if (ciss_vendor_data[i].flags & CISS_BOARD_SA5) {
626d69c9c78SScott Long 	sqmask = CISS_TL_SIMPLE_INTR_OPQ_SA5;
627d69c9c78SScott Long     } else if (ciss_vendor_data[i].flags & CISS_BOARD_SA5B) {
628d69c9c78SScott Long 	sqmask = CISS_TL_SIMPLE_INTR_OPQ_SA5B;
629d69c9c78SScott Long     } else {
630d69c9c78SScott Long 	/*
631d69c9c78SScott Long 	 * XXX Big hammer, masks/unmasks all possible interrupts.  This should
632d69c9c78SScott Long 	 * work on all hardware variants.  Need to add code to handle the
633b790c193SPedro F. Giffuni 	 * "controller crashed" interrupt bit that this unmasks.
634d69c9c78SScott Long 	 */
635d69c9c78SScott Long 	sqmask = ~0;
636d69c9c78SScott Long     }
637d69c9c78SScott Long 
638d69c9c78SScott Long     /*
6393a31b7ebSMike Smith      * Allocate register window first (we need this to find the config
6403a31b7ebSMike Smith      * struct).
6413a31b7ebSMike Smith      */
6423a31b7ebSMike Smith     error = ENXIO;
6433a31b7ebSMike Smith     sc->ciss_regs_rid = CISS_TL_SIMPLE_BAR_REGS;
6443a31b7ebSMike Smith     if ((sc->ciss_regs_resource =
6455f96beb9SNate Lawson 	 bus_alloc_resource_any(sc->ciss_dev, SYS_RES_MEMORY,
6465f96beb9SNate Lawson 				&sc->ciss_regs_rid, RF_ACTIVE)) == NULL) {
6473a31b7ebSMike Smith 	ciss_printf(sc, "can't allocate register window\n");
6483a31b7ebSMike Smith 	return(ENXIO);
6493a31b7ebSMike Smith     }
6503a31b7ebSMike Smith     sc->ciss_regs_bhandle = rman_get_bushandle(sc->ciss_regs_resource);
6513a31b7ebSMike Smith     sc->ciss_regs_btag = rman_get_bustag(sc->ciss_regs_resource);
6523a31b7ebSMike Smith 
6533a31b7ebSMike Smith     /*
6543a31b7ebSMike Smith      * Find the BAR holding the config structure.  If it's not the one
6553a31b7ebSMike Smith      * we already mapped for registers, map it too.
6563a31b7ebSMike Smith      */
6573a31b7ebSMike Smith     sc->ciss_cfg_rid = CISS_TL_SIMPLE_READ(sc, CISS_TL_SIMPLE_CFG_BAR) & 0xffff;
6583a31b7ebSMike Smith     if (sc->ciss_cfg_rid != sc->ciss_regs_rid) {
6593a31b7ebSMike Smith 	if ((sc->ciss_cfg_resource =
6605f96beb9SNate Lawson 	     bus_alloc_resource_any(sc->ciss_dev, SYS_RES_MEMORY,
6615f96beb9SNate Lawson 				    &sc->ciss_cfg_rid, RF_ACTIVE)) == NULL) {
6623a31b7ebSMike Smith 	    ciss_printf(sc, "can't allocate config window\n");
6633a31b7ebSMike Smith 	    return(ENXIO);
6643a31b7ebSMike Smith 	}
6653a31b7ebSMike Smith 	cbase = (uintptr_t)rman_get_virtual(sc->ciss_cfg_resource);
6663a31b7ebSMike Smith 	csize = rman_get_end(sc->ciss_cfg_resource) -
6673a31b7ebSMike Smith 	    rman_get_start(sc->ciss_cfg_resource) + 1;
6683a31b7ebSMike Smith     } else {
6693a31b7ebSMike Smith 	cbase = (uintptr_t)rman_get_virtual(sc->ciss_regs_resource);
6703a31b7ebSMike Smith 	csize = rman_get_end(sc->ciss_regs_resource) -
6713a31b7ebSMike Smith 	    rman_get_start(sc->ciss_regs_resource) + 1;
6723a31b7ebSMike Smith     }
6733a31b7ebSMike Smith     cofs = CISS_TL_SIMPLE_READ(sc, CISS_TL_SIMPLE_CFG_OFF);
6743a31b7ebSMike Smith 
6753a31b7ebSMike Smith     /*
6763a31b7ebSMike Smith      * Use the base/size/offset values we just calculated to
6773a31b7ebSMike Smith      * sanity-check the config structure.  If it's OK, point to it.
6783a31b7ebSMike Smith      */
6793a31b7ebSMike Smith     if ((cofs + sizeof(struct ciss_config_table)) > csize) {
6803a31b7ebSMike Smith 	ciss_printf(sc, "config table outside window\n");
6813a31b7ebSMike Smith 	return(ENXIO);
6823a31b7ebSMike Smith     }
6833a31b7ebSMike Smith     sc->ciss_cfg = (struct ciss_config_table *)(cbase + cofs);
6843a31b7ebSMike Smith     debug(1, "config struct at %p", sc->ciss_cfg);
6853a31b7ebSMike Smith 
6863a31b7ebSMike Smith     /*
68722657ce1SScott Long      * Calculate the number of request structures/commands we are
68822657ce1SScott Long      * going to provide for this adapter.
68922657ce1SScott Long      */
69022657ce1SScott Long     sc->ciss_max_requests = min(CISS_MAX_REQUESTS, sc->ciss_cfg->max_outstanding_commands);
69122657ce1SScott Long 
69222657ce1SScott Long     /*
6933a31b7ebSMike Smith      * Validate the config structure.  If we supported other transport
6943a31b7ebSMike Smith      * methods, we could select amongst them at this point in time.
6953a31b7ebSMike Smith      */
6963a31b7ebSMike Smith     if (strncmp(sc->ciss_cfg->signature, "CISS", 4)) {
6973a31b7ebSMike Smith 	ciss_printf(sc, "config signature mismatch (got '%c%c%c%c')\n",
6983a31b7ebSMike Smith 		    sc->ciss_cfg->signature[0], sc->ciss_cfg->signature[1],
6993a31b7ebSMike Smith 		    sc->ciss_cfg->signature[2], sc->ciss_cfg->signature[3]);
7003a31b7ebSMike Smith 	return(ENXIO);
7013a31b7ebSMike Smith     }
7023a31b7ebSMike Smith 
7033a31b7ebSMike Smith     /*
70422657ce1SScott Long      * Select the mode of operation, prefer Performant.
7053a31b7ebSMike Smith      */
70622657ce1SScott Long     if (!(sc->ciss_cfg->supported_methods &
70722657ce1SScott Long 	(CISS_TRANSPORT_METHOD_SIMPLE | CISS_TRANSPORT_METHOD_PERF))) {
70822657ce1SScott Long 	ciss_printf(sc, "No supported transport layers: 0x%x\n",
70922657ce1SScott Long 	    sc->ciss_cfg->supported_methods);
7103a31b7ebSMike Smith     }
71122657ce1SScott Long 
71222657ce1SScott Long     switch (ciss_force_transport) {
71322657ce1SScott Long     case 1:
71422657ce1SScott Long 	supported_methods = CISS_TRANSPORT_METHOD_SIMPLE;
71522657ce1SScott Long 	break;
71622657ce1SScott Long     case 2:
71722657ce1SScott Long 	supported_methods = CISS_TRANSPORT_METHOD_PERF;
71822657ce1SScott Long 	break;
71922657ce1SScott Long     default:
720ee4827b2SSean Bruno         /*
721ee4827b2SSean Bruno          * Override the capabilities of the BOARD and specify SIMPLE
722ee4827b2SSean Bruno          * MODE
723ee4827b2SSean Bruno          */
724ee4827b2SSean Bruno         if (ciss_vendor_data[i].flags & CISS_BOARD_SIMPLE)
725ee4827b2SSean Bruno                 supported_methods = CISS_TRANSPORT_METHOD_SIMPLE;
726ee4827b2SSean Bruno         else
72722657ce1SScott Long                 supported_methods = sc->ciss_cfg->supported_methods;
72822657ce1SScott Long         break;
72922657ce1SScott Long     }
73022657ce1SScott Long 
73122657ce1SScott Long setup:
7322fdaa90dSScott Long     if ((supported_methods & CISS_TRANSPORT_METHOD_PERF) != 0) {
73322657ce1SScott Long 	method = CISS_TRANSPORT_METHOD_PERF;
73422657ce1SScott Long 	sc->ciss_perf = (struct ciss_perf_config *)(cbase + cofs +
73522657ce1SScott Long 	    sc->ciss_cfg->transport_offset);
73622657ce1SScott Long 	if (ciss_init_perf(sc)) {
73722657ce1SScott Long 	    supported_methods &= ~method;
73822657ce1SScott Long 	    goto setup;
73922657ce1SScott Long 	}
74022657ce1SScott Long     } else if (supported_methods & CISS_TRANSPORT_METHOD_SIMPLE) {
74122657ce1SScott Long 	method = CISS_TRANSPORT_METHOD_SIMPLE;
74222657ce1SScott Long     } else {
74322657ce1SScott Long 	ciss_printf(sc, "No supported transport methods: 0x%x\n",
74422657ce1SScott Long 	    sc->ciss_cfg->supported_methods);
74522657ce1SScott Long 	return(ENXIO);
74622657ce1SScott Long     }
74722657ce1SScott Long 
74822657ce1SScott Long     /*
74922657ce1SScott Long      * Tell it we're using the low 4GB of RAM.  Set the default interrupt
75022657ce1SScott Long      * coalescing options.
75122657ce1SScott Long      */
75222657ce1SScott Long     sc->ciss_cfg->requested_method = method;
7533a31b7ebSMike Smith     sc->ciss_cfg->command_physlimit = 0;
7543a31b7ebSMike Smith     sc->ciss_cfg->interrupt_coalesce_delay = CISS_INTERRUPT_COALESCE_DELAY;
7553a31b7ebSMike Smith     sc->ciss_cfg->interrupt_coalesce_count = CISS_INTERRUPT_COALESCE_COUNT;
7563a31b7ebSMike Smith 
757a891a3bfSPaul Saab #ifdef __i386__
758a891a3bfSPaul Saab     sc->ciss_cfg->host_driver |= CISS_DRIVER_SCSI_PREFETCH;
759a891a3bfSPaul Saab #endif
760a891a3bfSPaul Saab 
7613a31b7ebSMike Smith     if (ciss_update_config(sc)) {
7623a31b7ebSMike Smith 	ciss_printf(sc, "adapter refuses to accept config update (IDBR 0x%x)\n",
7633a31b7ebSMike Smith 		    CISS_TL_SIMPLE_READ(sc, CISS_TL_SIMPLE_IDBR));
7643a31b7ebSMike Smith 	return(ENXIO);
7653a31b7ebSMike Smith     }
76622657ce1SScott Long     if ((sc->ciss_cfg->active_method & method) == 0) {
76722657ce1SScott Long 	supported_methods &= ~method;
76822657ce1SScott Long 	if (supported_methods == 0) {
76922657ce1SScott Long 	    ciss_printf(sc, "adapter refuses to go into available transports "
77022657ce1SScott Long 		"mode (0x%x, 0x%x)\n", supported_methods,
77122657ce1SScott Long 		sc->ciss_cfg->active_method);
7723a31b7ebSMike Smith 	    return(ENXIO);
77322657ce1SScott Long 	} else
77422657ce1SScott Long 	    goto setup;
7753a31b7ebSMike Smith     }
7763a31b7ebSMike Smith 
7773a31b7ebSMike Smith     /*
7783a31b7ebSMike Smith      * Wait for the adapter to come ready.
7793a31b7ebSMike Smith      */
7803a31b7ebSMike Smith     if ((error = ciss_wait_adapter(sc)) != 0)
7813a31b7ebSMike Smith 	return(error);
7823a31b7ebSMike Smith 
78322657ce1SScott Long     /* Prepare to possibly use MSIX and/or PERFORMANT interrupts.  Normal
78422657ce1SScott Long      * interrupts have a rid of 0, this will be overridden if MSIX is used.
78522657ce1SScott Long      */
78622657ce1SScott Long     sc->ciss_irq_rid[0] = 0;
78722657ce1SScott Long     if (method == CISS_TRANSPORT_METHOD_PERF) {
78822657ce1SScott Long 	ciss_printf(sc, "PERFORMANT Transport\n");
789d69c9c78SScott Long 	if ((ciss_force_interrupt != 1) && (ciss_setup_msix(sc) == 0)) {
79022657ce1SScott Long 	    intr = ciss_perf_msi_intr;
791d69c9c78SScott Long 	} else {
79222657ce1SScott Long 	    intr = ciss_perf_intr;
793d69c9c78SScott Long 	}
794b23be3e0SScott Long 	/* XXX The docs say that the 0x01 bit is only for SAS controllers.
795b23be3e0SScott Long 	 * Unfortunately, there is no good way to know if this is a SAS
796b23be3e0SScott Long 	 * controller.  Hopefully enabling this bit universally will work OK.
797b23be3e0SScott Long 	 * It seems to work fine for SA6i controllers.
798b23be3e0SScott Long 	 */
799b23be3e0SScott Long 	sc->ciss_interrupt_mask = CISS_TL_PERF_INTR_OPQ | CISS_TL_PERF_INTR_MSI;
800b23be3e0SScott Long 
80122657ce1SScott Long     } else {
80222657ce1SScott Long 	ciss_printf(sc, "SIMPLE Transport\n");
80322657ce1SScott Long 	/* MSIX doesn't seem to work in SIMPLE mode, only enable if it forced */
80422657ce1SScott Long 	if (ciss_force_interrupt == 2)
80522657ce1SScott Long 	    /* If this fails, we automatically revert to INTx */
80622657ce1SScott Long 	    ciss_setup_msix(sc);
80722657ce1SScott Long 	sc->ciss_perf = NULL;
80822657ce1SScott Long 	intr = ciss_intr;
809d69c9c78SScott Long 	sc->ciss_interrupt_mask = sqmask;
81022657ce1SScott Long     }
81122657ce1SScott Long 
8123a31b7ebSMike Smith     /*
8133a31b7ebSMike Smith      * Turn off interrupts before we go routing anything.
8143a31b7ebSMike Smith      */
8153a31b7ebSMike Smith     CISS_TL_SIMPLE_DISABLE_INTERRUPTS(sc);
8163a31b7ebSMike Smith 
8173a31b7ebSMike Smith     /*
8183a31b7ebSMike Smith      * Allocate and set up our interrupt.
8193a31b7ebSMike Smith      */
8203a31b7ebSMike Smith     if ((sc->ciss_irq_resource =
82122657ce1SScott Long 	 bus_alloc_resource_any(sc->ciss_dev, SYS_RES_IRQ, &sc->ciss_irq_rid[0],
8223a31b7ebSMike Smith 				RF_ACTIVE | RF_SHAREABLE)) == NULL) {
8233a31b7ebSMike Smith 	ciss_printf(sc, "can't allocate interrupt\n");
8243a31b7ebSMike Smith 	return(ENXIO);
8253a31b7ebSMike Smith     }
82622657ce1SScott Long 
827cc850363SPeter Wemm     if (bus_setup_intr(sc->ciss_dev, sc->ciss_irq_resource,
82822657ce1SScott Long 		       INTR_TYPE_CAM|INTR_MPSAFE, NULL, intr, sc,
8293a31b7ebSMike Smith 		       &sc->ciss_intr)) {
8303a31b7ebSMike Smith 	ciss_printf(sc, "can't set up interrupt\n");
8313a31b7ebSMike Smith 	return(ENXIO);
8323a31b7ebSMike Smith     }
8333a31b7ebSMike Smith 
8343a31b7ebSMike Smith     /*
8353a31b7ebSMike Smith      * Allocate the parent bus DMA tag appropriate for our PCI
8363a31b7ebSMike Smith      * interface.
8373a31b7ebSMike Smith      *
8383a31b7ebSMike Smith      * Note that "simple" adapters can only address within a 32-bit
8393a31b7ebSMike Smith      * span.
8403a31b7ebSMike Smith      */
841b6f97155SScott Long     if (bus_dma_tag_create(bus_get_dma_tag(sc->ciss_dev),/* PCI parent */
8423a31b7ebSMike Smith 			   1, 0, 			/* alignment, boundary */
843639717c8SPaul Saab 			   BUS_SPACE_MAXADDR,		/* lowaddr */
8443a31b7ebSMike Smith 			   BUS_SPACE_MAXADDR, 		/* highaddr */
8453a31b7ebSMike Smith 			   NULL, NULL, 			/* filter, filterarg */
846639717c8SPaul Saab 			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsize */
8476f954fb3SAlexander Motin 			   BUS_SPACE_UNRESTRICTED,	/* nsegments */
8483a31b7ebSMike Smith 			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
84922657ce1SScott Long 			   0,				/* flags */
850f6b1c44dSScott Long 			   NULL, NULL,			/* lockfunc, lockarg */
8513a31b7ebSMike Smith 			   &sc->ciss_parent_dmat)) {
8523a31b7ebSMike Smith 	ciss_printf(sc, "can't allocate parent DMA tag\n");
8533a31b7ebSMike Smith 	return(ENOMEM);
8543a31b7ebSMike Smith     }
8553a31b7ebSMike Smith 
8563a31b7ebSMike Smith     /*
8573a31b7ebSMike Smith      * Create DMA tag for mapping buffers into adapter-addressable
8583a31b7ebSMike Smith      * space.
8593a31b7ebSMike Smith      */
8603a31b7ebSMike Smith     if (bus_dma_tag_create(sc->ciss_parent_dmat, 	/* parent */
8613a31b7ebSMike Smith 			   1, 0, 			/* alignment, boundary */
8623a31b7ebSMike Smith 			   BUS_SPACE_MAXADDR,		/* lowaddr */
8633a31b7ebSMike Smith 			   BUS_SPACE_MAXADDR, 		/* highaddr */
8643a31b7ebSMike Smith 			   NULL, NULL, 			/* filter, filterarg */
8656f954fb3SAlexander Motin 			   (CISS_MAX_SG_ELEMENTS - 1) * PAGE_SIZE, /* maxsize */
8666f954fb3SAlexander Motin 			   CISS_MAX_SG_ELEMENTS,	/* nsegments */
8673a31b7ebSMike Smith 			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
86822657ce1SScott Long 			   BUS_DMA_ALLOCNOW,		/* flags */
869975b7318SScott Long 			   busdma_lock_mutex, &sc->ciss_mtx,	/* lockfunc, lockarg */
8703a31b7ebSMike Smith 			   &sc->ciss_buffer_dmat)) {
8713a31b7ebSMike Smith 	ciss_printf(sc, "can't allocate buffer DMA tag\n");
8723a31b7ebSMike Smith 	return(ENOMEM);
8733a31b7ebSMike Smith     }
8743a31b7ebSMike Smith     return(0);
8753a31b7ebSMike Smith }
8763a31b7ebSMike Smith 
8773a31b7ebSMike Smith /************************************************************************
87822657ce1SScott Long  * Setup MSI/MSIX operation (Performant only)
8792fdaa90dSScott Long  * Four interrupts are available, but we only use 1 right now.  If MSI-X
8802fdaa90dSScott Long  * isn't avaialble, try using MSI instead.
88122657ce1SScott Long  */
88222657ce1SScott Long static int
88322657ce1SScott Long ciss_setup_msix(struct ciss_softc *sc)
88422657ce1SScott Long {
88522657ce1SScott Long     int val, i;
88622657ce1SScott Long 
88722657ce1SScott Long     /* Weed out devices that don't actually support MSI */
8882fdaa90dSScott Long     i = ciss_lookup(sc->ciss_dev);
8892fdaa90dSScott Long     if (ciss_vendor_data[i].flags & CISS_BOARD_NOMSI)
89022657ce1SScott Long 	return (EINVAL);
89122657ce1SScott Long 
8922fdaa90dSScott Long     /*
8932fdaa90dSScott Long      * Only need to use the minimum number of MSI vectors, as the driver
8942fdaa90dSScott Long      * doesn't support directed MSIX interrupts.
8952fdaa90dSScott Long      */
89622657ce1SScott Long     val = pci_msix_count(sc->ciss_dev);
8972fdaa90dSScott Long     if (val < CISS_MSI_COUNT) {
8982fdaa90dSScott Long 	val = pci_msi_count(sc->ciss_dev);
8992fdaa90dSScott Long 	device_printf(sc->ciss_dev, "got %d MSI messages]\n", val);
900b23be3e0SScott Long 	if (val < CISS_MSI_COUNT)
901b23be3e0SScott Long 	    return (EINVAL);
9022fdaa90dSScott Long     }
903b23be3e0SScott Long     val = MIN(val, CISS_MSI_COUNT);
9042fdaa90dSScott Long     if (pci_alloc_msix(sc->ciss_dev, &val) != 0) {
9052fdaa90dSScott Long 	if (pci_alloc_msi(sc->ciss_dev, &val) != 0)
90622657ce1SScott Long 	    return (EINVAL);
9072fdaa90dSScott Long     }
90822657ce1SScott Long 
90922657ce1SScott Long     sc->ciss_msi = val;
9102fdaa90dSScott Long     if (bootverbose)
9112fdaa90dSScott Long 	ciss_printf(sc, "Using %d MSIX interrupt%s\n", val,
9122fdaa90dSScott Long 	    (val != 1) ? "s" : "");
91322657ce1SScott Long 
9142fdaa90dSScott Long     for (i = 0; i < val; i++)
91522657ce1SScott Long 	sc->ciss_irq_rid[i] = i + 1;
91622657ce1SScott Long 
91722657ce1SScott Long     return (0);
91822657ce1SScott Long 
91922657ce1SScott Long }
92022657ce1SScott Long 
92122657ce1SScott Long /************************************************************************
92222657ce1SScott Long  * Setup the Performant structures.
92322657ce1SScott Long  */
92422657ce1SScott Long static int
92522657ce1SScott Long ciss_init_perf(struct ciss_softc *sc)
92622657ce1SScott Long {
92722657ce1SScott Long     struct ciss_perf_config *pc = sc->ciss_perf;
92822657ce1SScott Long     int reply_size;
92922657ce1SScott Long 
93022657ce1SScott Long     /*
93122657ce1SScott Long      * Create the DMA tag for the reply queue.
93222657ce1SScott Long      */
93322657ce1SScott Long     reply_size = sizeof(uint64_t) * sc->ciss_max_requests;
93422657ce1SScott Long     if (bus_dma_tag_create(sc->ciss_parent_dmat,	/* parent */
93522657ce1SScott Long 			   1, 0, 			/* alignment, boundary */
93622657ce1SScott Long 			   BUS_SPACE_MAXADDR_32BIT,	/* lowaddr */
93722657ce1SScott Long 			   BUS_SPACE_MAXADDR, 		/* highaddr */
93822657ce1SScott Long 			   NULL, NULL, 			/* filter, filterarg */
93922657ce1SScott Long 			   reply_size, 1,		/* maxsize, nsegments */
94022657ce1SScott Long 			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
94122657ce1SScott Long 			   0,				/* flags */
94222657ce1SScott Long 			   NULL, NULL,			/* lockfunc, lockarg */
94322657ce1SScott Long 			   &sc->ciss_reply_dmat)) {
94422657ce1SScott Long 	ciss_printf(sc, "can't allocate reply DMA tag\n");
94522657ce1SScott Long 	return(ENOMEM);
94622657ce1SScott Long     }
94722657ce1SScott Long     /*
94822657ce1SScott Long      * Allocate memory and make it available for DMA.
94922657ce1SScott Long      */
95022657ce1SScott Long     if (bus_dmamem_alloc(sc->ciss_reply_dmat, (void **)&sc->ciss_reply,
95122657ce1SScott Long 			 BUS_DMA_NOWAIT, &sc->ciss_reply_map)) {
95222657ce1SScott Long 	ciss_printf(sc, "can't allocate reply memory\n");
95322657ce1SScott Long 	return(ENOMEM);
95422657ce1SScott Long     }
95522657ce1SScott Long     bus_dmamap_load(sc->ciss_reply_dmat, sc->ciss_reply_map, sc->ciss_reply,
95622657ce1SScott Long 		    reply_size, ciss_command_map_helper, &sc->ciss_reply_phys, 0);
95722657ce1SScott Long     bzero(sc->ciss_reply, reply_size);
95822657ce1SScott Long 
95922657ce1SScott Long     sc->ciss_cycle = 0x1;
96022657ce1SScott Long     sc->ciss_rqidx = 0;
96122657ce1SScott Long 
96222657ce1SScott Long     /*
96322657ce1SScott Long      * Preload the fetch table with common command sizes.  This allows the
96422657ce1SScott Long      * hardware to not waste bus cycles for typical i/o commands, but also not
96522657ce1SScott Long      * tax the driver to be too exact in choosing sizes.  The table is optimized
96622657ce1SScott Long      * for page-aligned i/o's, but since most i/o comes from the various pagers,
96722657ce1SScott Long      * it's a reasonable assumption to make.
96822657ce1SScott Long      */
96922657ce1SScott Long     pc->fetch_count[CISS_SG_FETCH_NONE] = (sizeof(struct ciss_command) + 15) / 16;
97022657ce1SScott Long     pc->fetch_count[CISS_SG_FETCH_1] =
97122657ce1SScott Long 	(sizeof(struct ciss_command) + sizeof(struct ciss_sg_entry) * 1 + 15) / 16;
97222657ce1SScott Long     pc->fetch_count[CISS_SG_FETCH_2] =
97322657ce1SScott Long 	(sizeof(struct ciss_command) + sizeof(struct ciss_sg_entry) * 2 + 15) / 16;
97422657ce1SScott Long     pc->fetch_count[CISS_SG_FETCH_4] =
97522657ce1SScott Long 	(sizeof(struct ciss_command) + sizeof(struct ciss_sg_entry) * 4 + 15) / 16;
97622657ce1SScott Long     pc->fetch_count[CISS_SG_FETCH_8] =
97722657ce1SScott Long 	(sizeof(struct ciss_command) + sizeof(struct ciss_sg_entry) * 8 + 15) / 16;
97822657ce1SScott Long     pc->fetch_count[CISS_SG_FETCH_16] =
97922657ce1SScott Long 	(sizeof(struct ciss_command) + sizeof(struct ciss_sg_entry) * 16 + 15) / 16;
98022657ce1SScott Long     pc->fetch_count[CISS_SG_FETCH_32] =
98122657ce1SScott Long 	(sizeof(struct ciss_command) + sizeof(struct ciss_sg_entry) * 32 + 15) / 16;
98222657ce1SScott Long     pc->fetch_count[CISS_SG_FETCH_MAX] = (CISS_COMMAND_ALLOC_SIZE + 15) / 16;
98322657ce1SScott Long 
98422657ce1SScott Long     pc->rq_size = sc->ciss_max_requests; /* XXX less than the card supports? */
98522657ce1SScott Long     pc->rq_count = 1;	/* XXX Hardcode for a single queue */
98622657ce1SScott Long     pc->rq_bank_hi = 0;
98722657ce1SScott Long     pc->rq_bank_lo = 0;
98822657ce1SScott Long     pc->rq[0].rq_addr_hi = 0x0;
98922657ce1SScott Long     pc->rq[0].rq_addr_lo = sc->ciss_reply_phys;
99022657ce1SScott Long 
99122657ce1SScott Long     return(0);
99222657ce1SScott Long }
99322657ce1SScott Long 
99422657ce1SScott Long /************************************************************************
9953a31b7ebSMike Smith  * Wait for the adapter to come ready.
9963a31b7ebSMike Smith  */
9973a31b7ebSMike Smith static int
9983a31b7ebSMike Smith ciss_wait_adapter(struct ciss_softc *sc)
9993a31b7ebSMike Smith {
10003a31b7ebSMike Smith     int		i;
10013a31b7ebSMike Smith 
10023a31b7ebSMike Smith     debug_called(1);
10033a31b7ebSMike Smith 
10043a31b7ebSMike Smith     /*
10053a31b7ebSMike Smith      * Wait for the adapter to come ready.
10063a31b7ebSMike Smith      */
10073a31b7ebSMike Smith     if (!(sc->ciss_cfg->active_method & CISS_TRANSPORT_METHOD_READY)) {
10083a31b7ebSMike Smith 	ciss_printf(sc, "waiting for adapter to come ready...\n");
10093a31b7ebSMike Smith 	for (i = 0; !(sc->ciss_cfg->active_method & CISS_TRANSPORT_METHOD_READY); i++) {
10103a31b7ebSMike Smith 	    DELAY(1000000);	/* one second */
10113a31b7ebSMike Smith 	    if (i > 30) {
10123a31b7ebSMike Smith 		ciss_printf(sc, "timed out waiting for adapter to come ready\n");
10133a31b7ebSMike Smith 		return(EIO);
10143a31b7ebSMike Smith 	    }
10153a31b7ebSMike Smith 	}
10163a31b7ebSMike Smith     }
10173a31b7ebSMike Smith     return(0);
10183a31b7ebSMike Smith }
10193a31b7ebSMike Smith 
10203a31b7ebSMike Smith /************************************************************************
10213a31b7ebSMike Smith  * Flush the adapter cache.
10223a31b7ebSMike Smith  */
10233a31b7ebSMike Smith static int
10243a31b7ebSMike Smith ciss_flush_adapter(struct ciss_softc *sc)
10253a31b7ebSMike Smith {
10263a31b7ebSMike Smith     struct ciss_request			*cr;
10273a31b7ebSMike Smith     struct ciss_bmic_flush_cache	*cbfc;
10283a31b7ebSMike Smith     int					error, command_status;
10293a31b7ebSMike Smith 
10303a31b7ebSMike Smith     debug_called(1);
10313a31b7ebSMike Smith 
10323a31b7ebSMike Smith     cr = NULL;
10333a31b7ebSMike Smith     cbfc = NULL;
10343a31b7ebSMike Smith 
10353a31b7ebSMike Smith     /*
10363a31b7ebSMike Smith      * Build a BMIC request to flush the cache.  We don't disable
10373a31b7ebSMike Smith      * it, as we may be going to do more I/O (eg. we are emulating
10383a31b7ebSMike Smith      * the Synchronise Cache command).
10393a31b7ebSMike Smith      */
10403a31b7ebSMike Smith     if ((cbfc = malloc(sizeof(*cbfc), CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO)) == NULL) {
10413a31b7ebSMike Smith 	error = ENOMEM;
10423a31b7ebSMike Smith 	goto out;
10433a31b7ebSMike Smith     }
10443a31b7ebSMike Smith     if ((error = ciss_get_bmic_request(sc, &cr, CISS_BMIC_FLUSH_CACHE,
10453a31b7ebSMike Smith 				       (void **)&cbfc, sizeof(*cbfc))) != 0)
10463a31b7ebSMike Smith 	goto out;
10473a31b7ebSMike Smith 
10483a31b7ebSMike Smith     /*
10493a31b7ebSMike Smith      * Submit the request and wait for it to complete.
10503a31b7ebSMike Smith      */
10513a31b7ebSMike Smith     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
10523a31b7ebSMike Smith 	ciss_printf(sc, "error sending BMIC FLUSH_CACHE command (%d)\n", error);
10533a31b7ebSMike Smith 	goto out;
10543a31b7ebSMike Smith     }
10553a31b7ebSMike Smith 
10563a31b7ebSMike Smith     /*
10573a31b7ebSMike Smith      * Check response.
10583a31b7ebSMike Smith      */
10593a31b7ebSMike Smith     ciss_report_request(cr, &command_status, NULL);
10603a31b7ebSMike Smith     switch(command_status) {
10613a31b7ebSMike Smith     case CISS_CMD_STATUS_SUCCESS:
10623a31b7ebSMike Smith 	break;
10633a31b7ebSMike Smith     default:
10643a31b7ebSMike Smith 	ciss_printf(sc, "error flushing cache (%s)\n",
10653a31b7ebSMike Smith 		    ciss_name_command_status(command_status));
10663a31b7ebSMike Smith 	error = EIO;
10673a31b7ebSMike Smith 	goto out;
10683a31b7ebSMike Smith     }
10693a31b7ebSMike Smith 
10703a31b7ebSMike Smith out:
10713a31b7ebSMike Smith     if (cbfc != NULL)
10723a31b7ebSMike Smith 	free(cbfc, CISS_MALLOC_CLASS);
10733a31b7ebSMike Smith     if (cr != NULL)
10743a31b7ebSMike Smith 	ciss_release_request(cr);
10753a31b7ebSMike Smith     return(error);
10763a31b7ebSMike Smith }
10773a31b7ebSMike Smith 
107817c0792dSPaul Saab static void
107917c0792dSPaul Saab ciss_soft_reset(struct ciss_softc *sc)
108017c0792dSPaul Saab {
108117c0792dSPaul Saab     struct ciss_request		*cr = NULL;
108217c0792dSPaul Saab     struct ciss_command		*cc;
108317c0792dSPaul Saab     int				i, error = 0;
108417c0792dSPaul Saab 
108517c0792dSPaul Saab     for (i = 0; i < sc->ciss_max_logical_bus; i++) {
108617c0792dSPaul Saab 	/* only reset proxy controllers */
108717c0792dSPaul Saab 	if (sc->ciss_controllers[i].physical.bus == 0)
108817c0792dSPaul Saab 	    continue;
108917c0792dSPaul Saab 
109017c0792dSPaul Saab 	if ((error = ciss_get_request(sc, &cr)) != 0)
109117c0792dSPaul Saab 	    break;
109217c0792dSPaul Saab 
109317c0792dSPaul Saab 	if ((error = ciss_get_bmic_request(sc, &cr, CISS_BMIC_SOFT_RESET,
109417c0792dSPaul Saab 					   NULL, 0)) != 0)
109517c0792dSPaul Saab 	    break;
109617c0792dSPaul Saab 
10972fdaa90dSScott Long 	cc = cr->cr_cc;
109817c0792dSPaul Saab 	cc->header.address = sc->ciss_controllers[i];
109917c0792dSPaul Saab 
110017c0792dSPaul Saab 	if ((error = ciss_synch_request(cr, 60 * 1000)) != 0)
110117c0792dSPaul Saab 	    break;
110217c0792dSPaul Saab 
110317c0792dSPaul Saab 	ciss_release_request(cr);
110417c0792dSPaul Saab     }
110517c0792dSPaul Saab 
110617c0792dSPaul Saab     if (error)
110717c0792dSPaul Saab 	ciss_printf(sc, "error resetting controller (%d)\n", error);
110817c0792dSPaul Saab 
110917c0792dSPaul Saab     if (cr != NULL)
111017c0792dSPaul Saab 	ciss_release_request(cr);
111117c0792dSPaul Saab }
111217c0792dSPaul Saab 
11133a31b7ebSMike Smith /************************************************************************
11143a31b7ebSMike Smith  * Allocate memory for the adapter command structures, initialise
11153a31b7ebSMike Smith  * the request structures.
11163a31b7ebSMike Smith  *
11173a31b7ebSMike Smith  * Note that the entire set of commands are allocated in a single
11183a31b7ebSMike Smith  * contiguous slab.
11193a31b7ebSMike Smith  */
11203a31b7ebSMike Smith static int
11213a31b7ebSMike Smith ciss_init_requests(struct ciss_softc *sc)
11223a31b7ebSMike Smith {
11233a31b7ebSMike Smith     struct ciss_request	*cr;
11243a31b7ebSMike Smith     int			i;
11253a31b7ebSMike Smith 
11263a31b7ebSMike Smith     debug_called(1);
11273a31b7ebSMike Smith 
11284bca277bSPaul Saab     if (bootverbose)
11293a31b7ebSMike Smith 	ciss_printf(sc, "using %d of %d available commands\n",
11303a31b7ebSMike Smith 		    sc->ciss_max_requests, sc->ciss_cfg->max_outstanding_commands);
11313a31b7ebSMike Smith 
11323a31b7ebSMike Smith     /*
11333a31b7ebSMike Smith      * Create the DMA tag for commands.
11343a31b7ebSMike Smith      */
11353a31b7ebSMike Smith     if (bus_dma_tag_create(sc->ciss_parent_dmat,	/* parent */
113622657ce1SScott Long 			   32, 0, 			/* alignment, boundary */
1137639717c8SPaul Saab 			   BUS_SPACE_MAXADDR_32BIT,	/* lowaddr */
11383a31b7ebSMike Smith 			   BUS_SPACE_MAXADDR, 		/* highaddr */
11393a31b7ebSMike Smith 			   NULL, NULL, 			/* filter, filterarg */
11403a31b7ebSMike Smith 			   CISS_COMMAND_ALLOC_SIZE *
11413a31b7ebSMike Smith 			   sc->ciss_max_requests, 1,	/* maxsize, nsegments */
11423a31b7ebSMike Smith 			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
114322657ce1SScott Long 			   0,				/* flags */
1144639717c8SPaul Saab 			   NULL, NULL,			/* lockfunc, lockarg */
11453a31b7ebSMike Smith 			   &sc->ciss_command_dmat)) {
11463a31b7ebSMike Smith 	ciss_printf(sc, "can't allocate command DMA tag\n");
11473a31b7ebSMike Smith 	return(ENOMEM);
11483a31b7ebSMike Smith     }
11493a31b7ebSMike Smith     /*
11503a31b7ebSMike Smith      * Allocate memory and make it available for DMA.
11513a31b7ebSMike Smith      */
11523a31b7ebSMike Smith     if (bus_dmamem_alloc(sc->ciss_command_dmat, (void **)&sc->ciss_command,
11533a31b7ebSMike Smith 			 BUS_DMA_NOWAIT, &sc->ciss_command_map)) {
11543a31b7ebSMike Smith 	ciss_printf(sc, "can't allocate command memory\n");
11553a31b7ebSMike Smith 	return(ENOMEM);
11563a31b7ebSMike Smith     }
11573a31b7ebSMike Smith     bus_dmamap_load(sc->ciss_command_dmat, sc->ciss_command_map,sc->ciss_command,
1158be241f79SPaul Saab 		    CISS_COMMAND_ALLOC_SIZE * sc->ciss_max_requests,
115922657ce1SScott Long 		    ciss_command_map_helper, &sc->ciss_command_phys, 0);
11603a31b7ebSMike Smith     bzero(sc->ciss_command, CISS_COMMAND_ALLOC_SIZE * sc->ciss_max_requests);
11613a31b7ebSMike Smith 
11623a31b7ebSMike Smith     /*
11633a31b7ebSMike Smith      * Set up the request and command structures, push requests onto
11643a31b7ebSMike Smith      * the free queue.
11653a31b7ebSMike Smith      */
11663a31b7ebSMike Smith     for (i = 1; i < sc->ciss_max_requests; i++) {
11673a31b7ebSMike Smith 	cr = &sc->ciss_request[i];
11683a31b7ebSMike Smith 	cr->cr_sc = sc;
11693a31b7ebSMike Smith 	cr->cr_tag = i;
11702fdaa90dSScott Long 	cr->cr_cc = (struct ciss_command *)((uintptr_t)sc->ciss_command +
11712fdaa90dSScott Long 	    CISS_COMMAND_ALLOC_SIZE * i);
11722fdaa90dSScott Long 	cr->cr_ccphys = sc->ciss_command_phys + CISS_COMMAND_ALLOC_SIZE * i;
11733284b9eeSPaul Saab 	bus_dmamap_create(sc->ciss_buffer_dmat, 0, &cr->cr_datamap);
11743a31b7ebSMike Smith 	ciss_enqueue_free(cr);
11753a31b7ebSMike Smith     }
11763a31b7ebSMike Smith     return(0);
11773a31b7ebSMike Smith }
11783a31b7ebSMike Smith 
11793a31b7ebSMike Smith static void
11803a31b7ebSMike Smith ciss_command_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
11813a31b7ebSMike Smith {
118222657ce1SScott Long     uint32_t *addr;
11833a31b7ebSMike Smith 
118422657ce1SScott Long     addr = arg;
118522657ce1SScott Long     *addr = segs[0].ds_addr;
11863a31b7ebSMike Smith }
11873a31b7ebSMike Smith 
11883a31b7ebSMike Smith /************************************************************************
11893a31b7ebSMike Smith  * Identify the adapter, print some information about it.
11903a31b7ebSMike Smith  */
11913a31b7ebSMike Smith static int
11923a31b7ebSMike Smith ciss_identify_adapter(struct ciss_softc *sc)
11933a31b7ebSMike Smith {
11943a31b7ebSMike Smith     struct ciss_request	*cr;
11953a31b7ebSMike Smith     int			error, command_status;
11963a31b7ebSMike Smith 
11973a31b7ebSMike Smith     debug_called(1);
11983a31b7ebSMike Smith 
11993a31b7ebSMike Smith     cr = NULL;
12003a31b7ebSMike Smith 
12013a31b7ebSMike Smith     /*
12023a31b7ebSMike Smith      * Get a request, allocate storage for the adapter data.
12033a31b7ebSMike Smith      */
12043a31b7ebSMike Smith     if ((error = ciss_get_bmic_request(sc, &cr, CISS_BMIC_ID_CTLR,
12053a31b7ebSMike Smith 				       (void **)&sc->ciss_id,
12063a31b7ebSMike Smith 				       sizeof(*sc->ciss_id))) != 0)
12073a31b7ebSMike Smith 	goto out;
12083a31b7ebSMike Smith 
12093a31b7ebSMike Smith     /*
12103a31b7ebSMike Smith      * Submit the request and wait for it to complete.
12113a31b7ebSMike Smith      */
12123a31b7ebSMike Smith     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
12133a31b7ebSMike Smith 	ciss_printf(sc, "error sending BMIC ID_CTLR command (%d)\n", error);
12143a31b7ebSMike Smith 	goto out;
12153a31b7ebSMike Smith     }
12163a31b7ebSMike Smith 
12173a31b7ebSMike Smith     /*
12183a31b7ebSMike Smith      * Check response.
12193a31b7ebSMike Smith      */
12203a31b7ebSMike Smith     ciss_report_request(cr, &command_status, NULL);
12213a31b7ebSMike Smith     switch(command_status) {
12223a31b7ebSMike Smith     case CISS_CMD_STATUS_SUCCESS:		/* buffer right size */
12233a31b7ebSMike Smith 	break;
12243a31b7ebSMike Smith     case CISS_CMD_STATUS_DATA_UNDERRUN:
12253a31b7ebSMike Smith     case CISS_CMD_STATUS_DATA_OVERRUN:
12263a31b7ebSMike Smith 	ciss_printf(sc, "data over/underrun reading adapter information\n");
12273a31b7ebSMike Smith     default:
12283a31b7ebSMike Smith 	ciss_printf(sc, "error reading adapter information (%s)\n",
12293a31b7ebSMike Smith 		    ciss_name_command_status(command_status));
12303a31b7ebSMike Smith 	error = EIO;
12313a31b7ebSMike Smith 	goto out;
12323a31b7ebSMike Smith     }
12333a31b7ebSMike Smith 
12343a31b7ebSMike Smith     /* sanity-check reply */
12350fb31ed0SSean Bruno     if (!(sc->ciss_id->controller_flags & CONTROLLER_FLAGS_BIG_MAP_SUPPORT)) {
12363a31b7ebSMike Smith 	ciss_printf(sc, "adapter does not support BIG_MAP\n");
12373a31b7ebSMike Smith 	error = ENXIO;
12383a31b7ebSMike Smith 	goto out;
12393a31b7ebSMike Smith     }
12403a31b7ebSMike Smith 
1241d4aa427fSPaul Saab #if 0
12423a31b7ebSMike Smith     /* XXX later revisions may not need this */
12433a31b7ebSMike Smith     sc->ciss_flags |= CISS_FLAG_FAKE_SYNCH;
1244d4aa427fSPaul Saab #endif
12453a31b7ebSMike Smith 
12463a31b7ebSMike Smith     /* XXX only really required for old 5300 adapters? */
12473a31b7ebSMike Smith     sc->ciss_flags |= CISS_FLAG_BMIC_ABORT;
12483a31b7ebSMike Smith 
1249e3edca22SSean Bruno     /*
1250e3edca22SSean Bruno      * Earlier controller specs do not contain these config
1251e3edca22SSean Bruno      * entries, so assume that a 0 means its old and assign
1252e3edca22SSean Bruno      * these values to the defaults that were established
1253e3edca22SSean Bruno      * when this driver was developed for them
1254e3edca22SSean Bruno      */
1255e3edca22SSean Bruno     if (sc->ciss_cfg->max_logical_supported == 0)
1256e3edca22SSean Bruno         sc->ciss_cfg->max_logical_supported = CISS_MAX_LOGICAL;
1257e3edca22SSean Bruno     if (sc->ciss_cfg->max_physical_supported == 0)
1258e3edca22SSean Bruno 	sc->ciss_cfg->max_physical_supported = CISS_MAX_PHYSICAL;
12593a31b7ebSMike Smith     /* print information */
12604bca277bSPaul Saab     if (bootverbose) {
12613a31b7ebSMike Smith 	ciss_printf(sc, "  %d logical drive%s configured\n",
12623a31b7ebSMike Smith 		    sc->ciss_id->configured_logical_drives,
12633a31b7ebSMike Smith 		    (sc->ciss_id->configured_logical_drives == 1) ? "" : "s");
12643a31b7ebSMike Smith 	ciss_printf(sc, "  firmware %4.4s\n", sc->ciss_id->running_firmware_revision);
12650fb31ed0SSean Bruno 	ciss_printf(sc, "  %d SCSI channels\n", sc->ciss_id->scsi_chip_count);
12663a31b7ebSMike Smith 
12673a31b7ebSMike Smith 	ciss_printf(sc, "  signature '%.4s'\n", sc->ciss_cfg->signature);
12683a31b7ebSMike Smith 	ciss_printf(sc, "  valence %d\n", sc->ciss_cfg->valence);
12693a31b7ebSMike Smith 	ciss_printf(sc, "  supported I/O methods 0x%b\n",
12703a31b7ebSMike Smith 		    sc->ciss_cfg->supported_methods,
12713a31b7ebSMike Smith 		    "\20\1READY\2simple\3performant\4MEMQ\n");
12723a31b7ebSMike Smith 	ciss_printf(sc, "  active I/O method 0x%b\n",
12733a31b7ebSMike Smith 		    sc->ciss_cfg->active_method, "\20\2simple\3performant\4MEMQ\n");
12743a31b7ebSMike Smith 	ciss_printf(sc, "  4G page base 0x%08x\n",
12753a31b7ebSMike Smith 		    sc->ciss_cfg->command_physlimit);
12763a31b7ebSMike Smith 	ciss_printf(sc, "  interrupt coalesce delay %dus\n",
12773a31b7ebSMike Smith 		    sc->ciss_cfg->interrupt_coalesce_delay);
12783a31b7ebSMike Smith 	ciss_printf(sc, "  interrupt coalesce count %d\n",
12793a31b7ebSMike Smith 		    sc->ciss_cfg->interrupt_coalesce_count);
12803a31b7ebSMike Smith 	ciss_printf(sc, "  max outstanding commands %d\n",
12813a31b7ebSMike Smith 		    sc->ciss_cfg->max_outstanding_commands);
12823a31b7ebSMike Smith 	ciss_printf(sc, "  bus types 0x%b\n", sc->ciss_cfg->bus_types,
12833a31b7ebSMike Smith 		    "\20\1ultra2\2ultra3\10fibre1\11fibre2\n");
12843a31b7ebSMike Smith 	ciss_printf(sc, "  server name '%.16s'\n", sc->ciss_cfg->server_name);
12853a31b7ebSMike Smith 	ciss_printf(sc, "  heartbeat 0x%x\n", sc->ciss_cfg->heartbeat);
1286*5f8cb13cSAlexander Motin 	ciss_printf(sc, "  max logical volumes: %d\n", sc->ciss_cfg->max_logical_supported);
1287e3edca22SSean Bruno     	ciss_printf(sc, "  max physical disks supported: %d\n", sc->ciss_cfg->max_physical_supported);
1288e3edca22SSean Bruno     	ciss_printf(sc, "  max physical disks per logical volume: %d\n", sc->ciss_cfg->max_physical_per_logical);
12890fb31ed0SSean Bruno 	ciss_printf(sc, "  JBOD Support is %s\n", (sc->ciss_id->uiYetMoreControllerFlags & YMORE_CONTROLLER_FLAGS_JBOD_SUPPORTED) ?
12900fb31ed0SSean Bruno 			"Available" : "Unavailable");
12910fb31ed0SSean Bruno 	ciss_printf(sc, "  JBOD Mode is %s\n", (sc->ciss_id->PowerUPNvramFlags & PWR_UP_FLAG_JBOD_ENABLED) ?
12920fb31ed0SSean Bruno 			"Enabled" : "Disabled");
12933a31b7ebSMike Smith     }
12943a31b7ebSMike Smith 
12953a31b7ebSMike Smith out:
12963a31b7ebSMike Smith     if (error) {
12973a31b7ebSMike Smith 	if (sc->ciss_id != NULL) {
12983a31b7ebSMike Smith 	    free(sc->ciss_id, CISS_MALLOC_CLASS);
12993a31b7ebSMike Smith 	    sc->ciss_id = NULL;
13003a31b7ebSMike Smith 	}
13013a31b7ebSMike Smith     }
13023a31b7ebSMike Smith     if (cr != NULL)
13033a31b7ebSMike Smith 	ciss_release_request(cr);
13043a31b7ebSMike Smith     return(error);
13053a31b7ebSMike Smith }
13063a31b7ebSMike Smith 
13073a31b7ebSMike Smith /************************************************************************
1308c6131460SPaul Saab  * Helper routine for generating a list of logical and physical luns.
13093a31b7ebSMike Smith  */
1310c6131460SPaul Saab static struct ciss_lun_report *
1311c6131460SPaul Saab ciss_report_luns(struct ciss_softc *sc, int opcode, int nunits)
13123a31b7ebSMike Smith {
13133a31b7ebSMike Smith     struct ciss_request		*cr;
13143a31b7ebSMike Smith     struct ciss_command		*cc;
13153a31b7ebSMike Smith     struct ciss_report_cdb	*crc;
13163a31b7ebSMike Smith     struct ciss_lun_report	*cll;
13173a31b7ebSMike Smith     int				command_status;
1318c6131460SPaul Saab     int				report_size;
1319c6131460SPaul Saab     int				error = 0;
13203a31b7ebSMike Smith 
13213a31b7ebSMike Smith     debug_called(1);
13223a31b7ebSMike Smith 
13233a31b7ebSMike Smith     cr = NULL;
13243a31b7ebSMike Smith     cll = NULL;
13253a31b7ebSMike Smith 
13263a31b7ebSMike Smith     /*
13273a31b7ebSMike Smith      * Get a request, allocate storage for the address list.
13283a31b7ebSMike Smith      */
13293a31b7ebSMike Smith     if ((error = ciss_get_request(sc, &cr)) != 0)
13303a31b7ebSMike Smith 	goto out;
1331c6131460SPaul Saab     report_size = sizeof(*cll) + nunits * sizeof(union ciss_device_address);
13323a31b7ebSMike Smith     if ((cll = malloc(report_size, CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO)) == NULL) {
1333c6131460SPaul Saab 	ciss_printf(sc, "can't allocate memory for lun report\n");
13343a31b7ebSMike Smith 	error = ENOMEM;
13353a31b7ebSMike Smith 	goto out;
13363a31b7ebSMike Smith     }
13373a31b7ebSMike Smith 
13383a31b7ebSMike Smith     /*
1339c6131460SPaul Saab      * Build the Report Logical/Physical LUNs command.
13403a31b7ebSMike Smith      */
13412fdaa90dSScott Long     cc = cr->cr_cc;
13423a31b7ebSMike Smith     cr->cr_data = cll;
13433a31b7ebSMike Smith     cr->cr_length = report_size;
13443a31b7ebSMike Smith     cr->cr_flags = CISS_REQ_DATAIN;
13453a31b7ebSMike Smith 
13463a31b7ebSMike Smith     cc->header.address.physical.mode = CISS_HDR_ADDRESS_MODE_PERIPHERAL;
13473a31b7ebSMike Smith     cc->header.address.physical.bus = 0;
13483a31b7ebSMike Smith     cc->header.address.physical.target = 0;
13493a31b7ebSMike Smith     cc->cdb.cdb_length = sizeof(*crc);
13503a31b7ebSMike Smith     cc->cdb.type = CISS_CDB_TYPE_COMMAND;
13513a31b7ebSMike Smith     cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;
13523a31b7ebSMike Smith     cc->cdb.direction = CISS_CDB_DIRECTION_READ;
13533a31b7ebSMike Smith     cc->cdb.timeout = 30;	/* XXX better suggestions? */
13543a31b7ebSMike Smith 
13553a31b7ebSMike Smith     crc = (struct ciss_report_cdb *)&(cc->cdb.cdb[0]);
13563a31b7ebSMike Smith     bzero(crc, sizeof(*crc));
1357c6131460SPaul Saab     crc->opcode = opcode;
13583a31b7ebSMike Smith     crc->length = htonl(report_size);			/* big-endian field */
13593a31b7ebSMike Smith     cll->list_size = htonl(report_size - sizeof(*cll));	/* big-endian field */
13603a31b7ebSMike Smith 
13613a31b7ebSMike Smith     /*
13623a31b7ebSMike Smith      * Submit the request and wait for it to complete.  (timeout
13633a31b7ebSMike Smith      * here should be much greater than above)
13643a31b7ebSMike Smith      */
13653a31b7ebSMike Smith     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
1366c6131460SPaul Saab 	ciss_printf(sc, "error sending %d LUN command (%d)\n", opcode, error);
13673a31b7ebSMike Smith 	goto out;
13683a31b7ebSMike Smith     }
13693a31b7ebSMike Smith 
13703a31b7ebSMike Smith     /*
13713a31b7ebSMike Smith      * Check response.  Note that data over/underrun is OK.
13723a31b7ebSMike Smith      */
13733a31b7ebSMike Smith     ciss_report_request(cr, &command_status, NULL);
13743a31b7ebSMike Smith     switch(command_status) {
13753a31b7ebSMike Smith     case CISS_CMD_STATUS_SUCCESS:	/* buffer right size */
13763a31b7ebSMike Smith     case CISS_CMD_STATUS_DATA_UNDERRUN:	/* buffer too large, not bad */
13773a31b7ebSMike Smith 	break;
13783a31b7ebSMike Smith     case CISS_CMD_STATUS_DATA_OVERRUN:
1379c6131460SPaul Saab 	ciss_printf(sc, "WARNING: more units than driver limit (%d)\n",
1380e3edca22SSean Bruno 		    sc->ciss_cfg->max_logical_supported);
13813a31b7ebSMike Smith 	break;
13823a31b7ebSMike Smith     default:
13833a31b7ebSMike Smith 	ciss_printf(sc, "error detecting logical drive configuration (%s)\n",
13843a31b7ebSMike Smith 		    ciss_name_command_status(command_status));
13853a31b7ebSMike Smith 	error = EIO;
13863a31b7ebSMike Smith 	goto out;
13873a31b7ebSMike Smith     }
13883a31b7ebSMike Smith     ciss_release_request(cr);
13893a31b7ebSMike Smith     cr = NULL;
13903a31b7ebSMike Smith 
1391c6131460SPaul Saab out:
1392c6131460SPaul Saab     if (cr != NULL)
1393c6131460SPaul Saab 	ciss_release_request(cr);
1394c6131460SPaul Saab     if (error && cll != NULL) {
1395c6131460SPaul Saab 	free(cll, CISS_MALLOC_CLASS);
1396c6131460SPaul Saab 	cll = NULL;
1397c6131460SPaul Saab     }
1398c6131460SPaul Saab     return(cll);
1399c6131460SPaul Saab }
1400c6131460SPaul Saab 
1401c6131460SPaul Saab /************************************************************************
1402c6131460SPaul Saab  * Find logical drives on the adapter.
1403c6131460SPaul Saab  */
1404c6131460SPaul Saab static int
1405c6131460SPaul Saab ciss_init_logical(struct ciss_softc *sc)
1406c6131460SPaul Saab {
1407c6131460SPaul Saab     struct ciss_lun_report	*cll;
1408c6131460SPaul Saab     int				error = 0, i, j;
1409c6131460SPaul Saab     int				ndrives;
1410c6131460SPaul Saab 
1411c6131460SPaul Saab     debug_called(1);
1412c6131460SPaul Saab 
1413c6131460SPaul Saab     cll = ciss_report_luns(sc, CISS_OPCODE_REPORT_LOGICAL_LUNS,
1414e3edca22SSean Bruno 			   sc->ciss_cfg->max_logical_supported);
1415c6131460SPaul Saab     if (cll == NULL) {
1416c6131460SPaul Saab 	error = ENXIO;
1417c6131460SPaul Saab 	goto out;
1418c6131460SPaul Saab     }
1419c6131460SPaul Saab 
14203a31b7ebSMike Smith     /* sanity-check reply */
14213a31b7ebSMike Smith     ndrives = (ntohl(cll->list_size) / sizeof(union ciss_device_address));
1422e3edca22SSean Bruno     if ((ndrives < 0) || (ndrives > sc->ciss_cfg->max_logical_supported)) {
14233a31b7ebSMike Smith 	ciss_printf(sc, "adapter claims to report absurd number of logical drives (%d > %d)\n",
1424e3edca22SSean Bruno 	    	ndrives, sc->ciss_cfg->max_logical_supported);
1425c6131460SPaul Saab 	error = ENXIO;
1426c6131460SPaul Saab 	goto out;
14273a31b7ebSMike Smith     }
14283a31b7ebSMike Smith 
14293a31b7ebSMike Smith     /*
14303a31b7ebSMike Smith      * Save logical drive information.
14313a31b7ebSMike Smith      */
1432c6131460SPaul Saab     if (bootverbose) {
1433c6131460SPaul Saab 	ciss_printf(sc, "%d logical drive%s\n",
1434c6131460SPaul Saab 	    ndrives, (ndrives > 1 || ndrives == 0) ? "s" : "");
1435c6131460SPaul Saab     }
1436c6131460SPaul Saab 
1437c6131460SPaul Saab     sc->ciss_logical =
1438ac2fffa4SPedro F. Giffuni 	malloc(sc->ciss_max_logical_bus * sizeof(struct ciss_ldrive *),
1439c6131460SPaul Saab 	       CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
1440c6131460SPaul Saab     if (sc->ciss_logical == NULL) {
1441c6131460SPaul Saab 	error = ENXIO;
1442c6131460SPaul Saab 	goto out;
1443c6131460SPaul Saab     }
1444c6131460SPaul Saab 
14455eae46afSConrad Meyer     for (i = 0; i < sc->ciss_max_logical_bus; i++) {
1446c6131460SPaul Saab 	sc->ciss_logical[i] =
1447ac2fffa4SPedro F. Giffuni 	    malloc(sc->ciss_cfg->max_logical_supported *
1448e3edca22SSean Bruno 		   sizeof(struct ciss_ldrive),
1449c6131460SPaul Saab 		   CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
1450c6131460SPaul Saab 	if (sc->ciss_logical[i] == NULL) {
1451c6131460SPaul Saab 	    error = ENXIO;
1452c6131460SPaul Saab 	    goto out;
1453c6131460SPaul Saab 	}
1454c6131460SPaul Saab 
1455e3edca22SSean Bruno 	for (j = 0; j < sc->ciss_cfg->max_logical_supported; j++)
1456c6131460SPaul Saab 	    sc->ciss_logical[i][j].cl_status = CISS_LD_NONEXISTENT;
1457c6131460SPaul Saab     }
1458c6131460SPaul Saab 
1459e3edca22SSean Bruno     for (i = 0; i < sc->ciss_cfg->max_logical_supported; i++) {
14603a31b7ebSMike Smith 	if (i < ndrives) {
1461c6131460SPaul Saab 	    struct ciss_ldrive	*ld;
1462c6131460SPaul Saab 	    int			bus, target;
1463c6131460SPaul Saab 
1464c6131460SPaul Saab 	    bus		= CISS_LUN_TO_BUS(cll->lun[i].logical.lun);
1465c6131460SPaul Saab 	    target	= CISS_LUN_TO_TARGET(cll->lun[i].logical.lun);
1466c6131460SPaul Saab 	    ld		= &sc->ciss_logical[bus][target];
1467c6131460SPaul Saab 
1468c6131460SPaul Saab 	    ld->cl_address	= cll->lun[i];
1469c6131460SPaul Saab 	    ld->cl_controller	= &sc->ciss_controllers[bus];
1470c6131460SPaul Saab 	    if (ciss_identify_logical(sc, ld) != 0)
14713a31b7ebSMike Smith 		continue;
14723a31b7ebSMike Smith 	    /*
14733a31b7ebSMike Smith 	     * If the drive has had media exchanged, we should bring it online.
14743a31b7ebSMike Smith 	     */
1475c6131460SPaul Saab 	    if (ld->cl_lstatus->media_exchanged)
147688c78a38SPaul Saab 		ciss_accept_media(sc, ld);
14773a31b7ebSMike Smith 	}
14783a31b7ebSMike Smith     }
14793a31b7ebSMike Smith 
14803a31b7ebSMike Smith  out:
14813a31b7ebSMike Smith     if (cll != NULL)
14823a31b7ebSMike Smith 	free(cll, CISS_MALLOC_CLASS);
14833a31b7ebSMike Smith     return(error);
14843a31b7ebSMike Smith }
14853a31b7ebSMike Smith 
1486440baa08SPaul Saab static int
1487c6131460SPaul Saab ciss_init_physical(struct ciss_softc *sc)
1488c6131460SPaul Saab {
1489c6131460SPaul Saab     struct ciss_lun_report	*cll;
1490c6131460SPaul Saab     int				error = 0, i;
1491c6131460SPaul Saab     int				nphys;
14921fe6c4eeSScott Long     int				bus, target;
1493c6131460SPaul Saab 
1494c6131460SPaul Saab     debug_called(1);
1495c6131460SPaul Saab 
14961fe6c4eeSScott Long     bus = 0;
14971fe6c4eeSScott Long     target = 0;
14981fe6c4eeSScott Long 
1499c6131460SPaul Saab     cll = ciss_report_luns(sc, CISS_OPCODE_REPORT_PHYSICAL_LUNS,
1500e3edca22SSean Bruno 			   sc->ciss_cfg->max_physical_supported);
1501c6131460SPaul Saab     if (cll == NULL) {
1502c6131460SPaul Saab 	error = ENXIO;
1503c6131460SPaul Saab 	goto out;
1504c6131460SPaul Saab     }
1505c6131460SPaul Saab 
1506c6131460SPaul Saab     nphys = (ntohl(cll->list_size) / sizeof(union ciss_device_address));
1507c6131460SPaul Saab 
1508c6131460SPaul Saab     if (bootverbose) {
1509c6131460SPaul Saab 	ciss_printf(sc, "%d physical device%s\n",
1510c6131460SPaul Saab 	    nphys, (nphys > 1 || nphys == 0) ? "s" : "");
1511c6131460SPaul Saab     }
1512c6131460SPaul Saab 
1513c6131460SPaul Saab     /*
15141fe6c4eeSScott Long      * Figure out the bus mapping.
15151fe6c4eeSScott Long      * Logical buses include both the local logical bus for local arrays and
15161fe6c4eeSScott Long      * proxy buses for remote arrays.  Physical buses are numbered by the
15171fe6c4eeSScott Long      * controller and represent physical buses that hold physical devices.
15181fe6c4eeSScott Long      * We shift these bus numbers so that everything fits into a single flat
15191fe6c4eeSScott Long      * numbering space for CAM.  Logical buses occupy the first 32 CAM bus
15201fe6c4eeSScott Long      * numbers, and the physical bus numbers are shifted to be above that.
15211fe6c4eeSScott Long      * This results in the various driver arrays being indexed as follows:
15221fe6c4eeSScott Long      *
15231fe6c4eeSScott Long      * ciss_controllers[] - indexed by logical bus
15241fe6c4eeSScott Long      * ciss_cam_sim[]     - indexed by both logical and physical, with physical
15251fe6c4eeSScott Long      *                      being shifted by 32.
15261fe6c4eeSScott Long      * ciss_logical[][]   - indexed by logical bus
15271fe6c4eeSScott Long      * ciss_physical[][]  - indexed by physical bus
15281fe6c4eeSScott Long      *
15291fe6c4eeSScott Long      * XXX This is getting more and more hackish.  CISS really doesn't play
15301fe6c4eeSScott Long      *     well with a standard SCSI model; devices are addressed via magic
15311fe6c4eeSScott Long      *     cookies, not via b/t/l addresses.  Since there is no way to store
15321fe6c4eeSScott Long      *     the cookie in the CAM device object, we have to keep these lookup
15331fe6c4eeSScott Long      *     tables handy so that the devices can be found quickly at the cost
15341fe6c4eeSScott Long      *     of wasting memory and having a convoluted lookup scheme.  This
15351fe6c4eeSScott Long      *     driver should probably be converted to block interface.
15361fe6c4eeSScott Long      */
15371fe6c4eeSScott Long     /*
1538c6131460SPaul Saab      * If the L2 and L3 SCSI addresses are 0, this signifies a proxy
1539c6131460SPaul Saab      * controller. A proxy controller is another physical controller
1540c6131460SPaul Saab      * behind the primary PCI controller. We need to know about this
1541c6131460SPaul Saab      * so that BMIC commands can be properly targeted.  There can be
1542c6131460SPaul Saab      * proxy controllers attached to a single PCI controller, so
1543c6131460SPaul Saab      * find the highest numbered one so the array can be properly
1544c6131460SPaul Saab      * sized.
1545c6131460SPaul Saab      */
15461fe6c4eeSScott Long     sc->ciss_max_logical_bus = 1;
1547c6131460SPaul Saab     for (i = 0; i < nphys; i++) {
1548c6131460SPaul Saab 	if (cll->lun[i].physical.extra_address == 0) {
15491fe6c4eeSScott Long 	    bus = cll->lun[i].physical.bus;
15501fe6c4eeSScott Long 	    sc->ciss_max_logical_bus = max(sc->ciss_max_logical_bus, bus) + 1;
15511fe6c4eeSScott Long 	} else {
15521fe6c4eeSScott Long 	    bus = CISS_EXTRA_BUS2(cll->lun[i].physical.extra_address);
15531fe6c4eeSScott Long 	    sc->ciss_max_physical_bus = max(sc->ciss_max_physical_bus, bus);
1554c6131460SPaul Saab 	}
1555c6131460SPaul Saab     }
1556c6131460SPaul Saab 
1557c6131460SPaul Saab     sc->ciss_controllers =
1558ac2fffa4SPedro F. Giffuni 	malloc(sc->ciss_max_logical_bus * sizeof (union ciss_device_address),
1559c6131460SPaul Saab 	       CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
1560c6131460SPaul Saab 
1561c6131460SPaul Saab     if (sc->ciss_controllers == NULL) {
1562c6131460SPaul Saab 	ciss_printf(sc, "Could not allocate memory for controller map\n");
1563c6131460SPaul Saab 	error = ENOMEM;
1564c6131460SPaul Saab 	goto out;
1565c6131460SPaul Saab     }
1566c6131460SPaul Saab 
1567c6131460SPaul Saab     /* setup a map of controller addresses */
1568c6131460SPaul Saab     for (i = 0; i < nphys; i++) {
1569c6131460SPaul Saab 	if (cll->lun[i].physical.extra_address == 0) {
1570c6131460SPaul Saab 	    sc->ciss_controllers[cll->lun[i].physical.bus] = cll->lun[i];
1571c6131460SPaul Saab 	}
1572c6131460SPaul Saab     }
1573c6131460SPaul Saab 
15741fe6c4eeSScott Long     sc->ciss_physical =
1575ac2fffa4SPedro F. Giffuni 	malloc(sc->ciss_max_physical_bus * sizeof(struct ciss_pdrive *),
15761fe6c4eeSScott Long 	       CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
15771fe6c4eeSScott Long     if (sc->ciss_physical == NULL) {
15781fe6c4eeSScott Long 	ciss_printf(sc, "Could not allocate memory for physical device map\n");
15791fe6c4eeSScott Long 	error = ENOMEM;
15801fe6c4eeSScott Long 	goto out;
15811fe6c4eeSScott Long     }
15821fe6c4eeSScott Long 
15831fe6c4eeSScott Long     for (i = 0; i < sc->ciss_max_physical_bus; i++) {
15841fe6c4eeSScott Long 	sc->ciss_physical[i] =
15851fe6c4eeSScott Long 	    malloc(sizeof(struct ciss_pdrive) * CISS_MAX_PHYSTGT,
15861fe6c4eeSScott Long 		   CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
15871fe6c4eeSScott Long 	if (sc->ciss_physical[i] == NULL) {
15881fe6c4eeSScott Long 	    ciss_printf(sc, "Could not allocate memory for target map\n");
15891fe6c4eeSScott Long 	    error = ENOMEM;
15901fe6c4eeSScott Long 	    goto out;
15911fe6c4eeSScott Long 	}
15921fe6c4eeSScott Long     }
15931fe6c4eeSScott Long 
15941fe6c4eeSScott Long     ciss_filter_physical(sc, cll);
15951fe6c4eeSScott Long 
1596c6131460SPaul Saab out:
1597c6131460SPaul Saab     if (cll != NULL)
1598c6131460SPaul Saab 	free(cll, CISS_MALLOC_CLASS);
1599c6131460SPaul Saab 
1600c6131460SPaul Saab     return(error);
1601c6131460SPaul Saab }
1602c6131460SPaul Saab 
1603c6131460SPaul Saab static int
16041fe6c4eeSScott Long ciss_filter_physical(struct ciss_softc *sc, struct ciss_lun_report *cll)
16051fe6c4eeSScott Long {
16061fe6c4eeSScott Long     u_int32_t ea;
16071fe6c4eeSScott Long     int i, nphys;
16081fe6c4eeSScott Long     int	bus, target;
16091fe6c4eeSScott Long 
16101fe6c4eeSScott Long     nphys = (ntohl(cll->list_size) / sizeof(union ciss_device_address));
16111fe6c4eeSScott Long     for (i = 0; i < nphys; i++) {
16121fe6c4eeSScott Long 	if (cll->lun[i].physical.extra_address == 0)
16131fe6c4eeSScott Long 	    continue;
16141fe6c4eeSScott Long 
16151fe6c4eeSScott Long 	/*
16161fe6c4eeSScott Long 	 * Filter out devices that we don't want.  Level 3 LUNs could
16171fe6c4eeSScott Long 	 * probably be supported, but the docs don't give enough of a
16181fe6c4eeSScott Long 	 * hint to know how.
16191fe6c4eeSScott Long 	 *
16201fe6c4eeSScott Long 	 * The mode field of the physical address is likely set to have
16211fe6c4eeSScott Long 	 * hard disks masked out.  Honor it unless the user has overridden
16221fe6c4eeSScott Long 	 * us with the tunable.  We also munge the inquiry data for these
16231fe6c4eeSScott Long 	 * disks so that they only show up as passthrough devices.  Keeping
16241fe6c4eeSScott Long 	 * them visible in this fashion is useful for doing things like
16251fe6c4eeSScott Long 	 * flashing firmware.
16261fe6c4eeSScott Long 	 */
16271fe6c4eeSScott Long 	ea = cll->lun[i].physical.extra_address;
16281fe6c4eeSScott Long 	if ((CISS_EXTRA_BUS3(ea) != 0) || (CISS_EXTRA_TARGET3(ea) != 0) ||
16291fe6c4eeSScott Long 	    (CISS_EXTRA_MODE2(ea) == 0x3))
16301fe6c4eeSScott Long 	    continue;
16311fe6c4eeSScott Long 	if ((ciss_expose_hidden_physical == 0) &&
16321fe6c4eeSScott Long 	   (cll->lun[i].physical.mode == CISS_HDR_ADDRESS_MODE_MASK_PERIPHERAL))
16331fe6c4eeSScott Long 	    continue;
16341fe6c4eeSScott Long 
16351fe6c4eeSScott Long 	/*
16361fe6c4eeSScott Long 	 * Note: CISS firmware numbers physical busses starting at '1', not
16371fe6c4eeSScott Long 	 *       '0'.  This numbering is internal to the firmware and is only
16381fe6c4eeSScott Long 	 *       used as a hint here.
16391fe6c4eeSScott Long 	 */
16401fe6c4eeSScott Long 	bus = CISS_EXTRA_BUS2(ea) - 1;
16411fe6c4eeSScott Long 	target = CISS_EXTRA_TARGET2(ea);
16421fe6c4eeSScott Long 	sc->ciss_physical[bus][target].cp_address = cll->lun[i];
16431fe6c4eeSScott Long 	sc->ciss_physical[bus][target].cp_online = 1;
16441fe6c4eeSScott Long     }
16451fe6c4eeSScott Long 
16461fe6c4eeSScott Long     return (0);
16471fe6c4eeSScott Long }
16481fe6c4eeSScott Long 
16491fe6c4eeSScott Long static int
1650440baa08SPaul Saab ciss_inquiry_logical(struct ciss_softc *sc, struct ciss_ldrive *ld)
1651440baa08SPaul Saab {
1652440baa08SPaul Saab     struct ciss_request			*cr;
1653440baa08SPaul Saab     struct ciss_command			*cc;
1654440baa08SPaul Saab     struct scsi_inquiry			*inq;
1655440baa08SPaul Saab     int					error;
1656440baa08SPaul Saab     int					command_status;
1657440baa08SPaul Saab 
1658440baa08SPaul Saab     cr = NULL;
1659440baa08SPaul Saab 
1660440baa08SPaul Saab     bzero(&ld->cl_geometry, sizeof(ld->cl_geometry));
1661440baa08SPaul Saab 
1662440baa08SPaul Saab     if ((error = ciss_get_request(sc, &cr)) != 0)
1663440baa08SPaul Saab 	goto out;
1664440baa08SPaul Saab 
16652fdaa90dSScott Long     cc = cr->cr_cc;
1666440baa08SPaul Saab     cr->cr_data = &ld->cl_geometry;
1667440baa08SPaul Saab     cr->cr_length = sizeof(ld->cl_geometry);
1668440baa08SPaul Saab     cr->cr_flags = CISS_REQ_DATAIN;
1669440baa08SPaul Saab 
1670c6131460SPaul Saab     cc->header.address = ld->cl_address;
1671440baa08SPaul Saab     cc->cdb.cdb_length = 6;
1672440baa08SPaul Saab     cc->cdb.type = CISS_CDB_TYPE_COMMAND;
1673440baa08SPaul Saab     cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;
1674440baa08SPaul Saab     cc->cdb.direction = CISS_CDB_DIRECTION_READ;
1675440baa08SPaul Saab     cc->cdb.timeout = 30;
1676440baa08SPaul Saab 
1677440baa08SPaul Saab     inq = (struct scsi_inquiry *)&(cc->cdb.cdb[0]);
1678440baa08SPaul Saab     inq->opcode = INQUIRY;
1679440baa08SPaul Saab     inq->byte2 = SI_EVPD;
1680440baa08SPaul Saab     inq->page_code = CISS_VPD_LOGICAL_DRIVE_GEOMETRY;
1681130f4520SKenneth D. Merry     scsi_ulto2b(sizeof(ld->cl_geometry), inq->length);
1682440baa08SPaul Saab 
1683440baa08SPaul Saab     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
1684440baa08SPaul Saab 	ciss_printf(sc, "error getting geometry (%d)\n", error);
1685440baa08SPaul Saab 	goto out;
1686440baa08SPaul Saab     }
1687440baa08SPaul Saab 
1688440baa08SPaul Saab     ciss_report_request(cr, &command_status, NULL);
1689440baa08SPaul Saab     switch(command_status) {
1690440baa08SPaul Saab     case CISS_CMD_STATUS_SUCCESS:
1691440baa08SPaul Saab     case CISS_CMD_STATUS_DATA_UNDERRUN:
1692440baa08SPaul Saab 	break;
1693440baa08SPaul Saab     case CISS_CMD_STATUS_DATA_OVERRUN:
1694440baa08SPaul Saab 	ciss_printf(sc, "WARNING: Data overrun\n");
1695440baa08SPaul Saab 	break;
1696440baa08SPaul Saab     default:
1697440baa08SPaul Saab 	ciss_printf(sc, "Error detecting logical drive geometry (%s)\n",
1698440baa08SPaul Saab 		    ciss_name_command_status(command_status));
1699440baa08SPaul Saab 	break;
1700440baa08SPaul Saab     }
1701440baa08SPaul Saab 
1702440baa08SPaul Saab out:
1703440baa08SPaul Saab     if (cr != NULL)
1704440baa08SPaul Saab 	ciss_release_request(cr);
1705440baa08SPaul Saab     return(error);
1706440baa08SPaul Saab }
17073a31b7ebSMike Smith /************************************************************************
17083a31b7ebSMike Smith  * Identify a logical drive, initialise state related to it.
17093a31b7ebSMike Smith  */
17103a31b7ebSMike Smith static int
17113a31b7ebSMike Smith ciss_identify_logical(struct ciss_softc *sc, struct ciss_ldrive *ld)
17123a31b7ebSMike Smith {
17133a31b7ebSMike Smith     struct ciss_request		*cr;
17143a31b7ebSMike Smith     struct ciss_command		*cc;
17153a31b7ebSMike Smith     struct ciss_bmic_cdb	*cbc;
17163a31b7ebSMike Smith     int				error, command_status;
17173a31b7ebSMike Smith 
17183a31b7ebSMike Smith     debug_called(1);
17193a31b7ebSMike Smith 
17203a31b7ebSMike Smith     cr = NULL;
17213a31b7ebSMike Smith 
17223a31b7ebSMike Smith     /*
17233a31b7ebSMike Smith      * Build a BMIC request to fetch the drive ID.
17243a31b7ebSMike Smith      */
17253a31b7ebSMike Smith     if ((error = ciss_get_bmic_request(sc, &cr, CISS_BMIC_ID_LDRIVE,
17263a31b7ebSMike Smith 				       (void **)&ld->cl_ldrive,
17273a31b7ebSMike Smith 				       sizeof(*ld->cl_ldrive))) != 0)
17283a31b7ebSMike Smith 	goto out;
17292fdaa90dSScott Long     cc = cr->cr_cc;
1730c6131460SPaul Saab     cc->header.address = *ld->cl_controller;	/* target controller */
17313a31b7ebSMike Smith     cbc = (struct ciss_bmic_cdb *)&(cc->cdb.cdb[0]);
1732c6131460SPaul Saab     cbc->log_drive = CISS_LUN_TO_TARGET(ld->cl_address.logical.lun);
17333a31b7ebSMike Smith 
17343a31b7ebSMike Smith     /*
17353a31b7ebSMike Smith      * Submit the request and wait for it to complete.
17363a31b7ebSMike Smith      */
17373a31b7ebSMike Smith     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
17383a31b7ebSMike Smith 	ciss_printf(sc, "error sending BMIC LDRIVE command (%d)\n", error);
17393a31b7ebSMike Smith 	goto out;
17403a31b7ebSMike Smith     }
17413a31b7ebSMike Smith 
17423a31b7ebSMike Smith     /*
17433a31b7ebSMike Smith      * Check response.
17443a31b7ebSMike Smith      */
17453a31b7ebSMike Smith     ciss_report_request(cr, &command_status, NULL);
17463a31b7ebSMike Smith     switch(command_status) {
17473a31b7ebSMike Smith     case CISS_CMD_STATUS_SUCCESS:		/* buffer right size */
17483a31b7ebSMike Smith 	break;
17493a31b7ebSMike Smith     case CISS_CMD_STATUS_DATA_UNDERRUN:
17503a31b7ebSMike Smith     case CISS_CMD_STATUS_DATA_OVERRUN:
17513a31b7ebSMike Smith 	ciss_printf(sc, "data over/underrun reading logical drive ID\n");
17523a31b7ebSMike Smith     default:
17533a31b7ebSMike Smith 	ciss_printf(sc, "error reading logical drive ID (%s)\n",
17543a31b7ebSMike Smith 		    ciss_name_command_status(command_status));
17553a31b7ebSMike Smith 	error = EIO;
17563a31b7ebSMike Smith 	goto out;
17573a31b7ebSMike Smith     }
17583a31b7ebSMike Smith     ciss_release_request(cr);
17593a31b7ebSMike Smith     cr = NULL;
17603a31b7ebSMike Smith 
17613a31b7ebSMike Smith     /*
17623a31b7ebSMike Smith      * Build a CISS BMIC command to get the logical drive status.
17633a31b7ebSMike Smith      */
17643a31b7ebSMike Smith     if ((error = ciss_get_ldrive_status(sc, ld)) != 0)
17653a31b7ebSMike Smith 	goto out;
17663a31b7ebSMike Smith 
17673a31b7ebSMike Smith     /*
1768440baa08SPaul Saab      * Get the logical drive geometry.
1769440baa08SPaul Saab      */
1770440baa08SPaul Saab     if ((error = ciss_inquiry_logical(sc, ld)) != 0)
1771440baa08SPaul Saab 	goto out;
1772440baa08SPaul Saab 
1773440baa08SPaul Saab     /*
17743a31b7ebSMike Smith      * Print the drive's basic characteristics.
17753a31b7ebSMike Smith      */
17764bca277bSPaul Saab     if (bootverbose) {
1777c6131460SPaul Saab 	ciss_printf(sc, "logical drive (b%dt%d): %s, %dMB ",
1778c6131460SPaul Saab 		    CISS_LUN_TO_BUS(ld->cl_address.logical.lun),
1779c6131460SPaul Saab 		    CISS_LUN_TO_TARGET(ld->cl_address.logical.lun),
178079adbf76SPaul Saab 		    ciss_name_ldrive_org(ld->cl_ldrive->fault_tolerance),
17813a31b7ebSMike Smith 		    ((ld->cl_ldrive->blocks_available / (1024 * 1024)) *
17823a31b7ebSMike Smith 		     ld->cl_ldrive->block_size));
17833a31b7ebSMike Smith 
17843a31b7ebSMike Smith 	ciss_print_ldrive(sc, ld);
17853a31b7ebSMike Smith     }
17863a31b7ebSMike Smith out:
17873a31b7ebSMike Smith     if (error != 0) {
17883a31b7ebSMike Smith 	/* make the drive not-exist */
17893a31b7ebSMike Smith 	ld->cl_status = CISS_LD_NONEXISTENT;
17903a31b7ebSMike Smith 	if (ld->cl_ldrive != NULL) {
17913a31b7ebSMike Smith 	    free(ld->cl_ldrive, CISS_MALLOC_CLASS);
17923a31b7ebSMike Smith 	    ld->cl_ldrive = NULL;
17933a31b7ebSMike Smith 	}
17943a31b7ebSMike Smith 	if (ld->cl_lstatus != NULL) {
17953a31b7ebSMike Smith 	    free(ld->cl_lstatus, CISS_MALLOC_CLASS);
17963a31b7ebSMike Smith 	    ld->cl_lstatus = NULL;
17973a31b7ebSMike Smith 	}
17983a31b7ebSMike Smith     }
17993a31b7ebSMike Smith     if (cr != NULL)
18003a31b7ebSMike Smith 	ciss_release_request(cr);
18013a31b7ebSMike Smith 
18023a31b7ebSMike Smith     return(error);
18033a31b7ebSMike Smith }
18043a31b7ebSMike Smith 
18053a31b7ebSMike Smith /************************************************************************
18063a31b7ebSMike Smith  * Get status for a logical drive.
18073a31b7ebSMike Smith  *
18083a31b7ebSMike Smith  * XXX should we also do this in response to Test Unit Ready?
18093a31b7ebSMike Smith  */
18103a31b7ebSMike Smith static int
18113a31b7ebSMike Smith ciss_get_ldrive_status(struct ciss_softc *sc,  struct ciss_ldrive *ld)
18123a31b7ebSMike Smith {
18133a31b7ebSMike Smith     struct ciss_request		*cr;
18143a31b7ebSMike Smith     struct ciss_command		*cc;
18153a31b7ebSMike Smith     struct ciss_bmic_cdb	*cbc;
18163a31b7ebSMike Smith     int				error, command_status;
18173a31b7ebSMike Smith 
18183a31b7ebSMike Smith     /*
18193a31b7ebSMike Smith      * Build a CISS BMIC command to get the logical drive status.
18203a31b7ebSMike Smith      */
18213a31b7ebSMike Smith     if ((error = ciss_get_bmic_request(sc, &cr, CISS_BMIC_ID_LSTATUS,
18223a31b7ebSMike Smith 				       (void **)&ld->cl_lstatus,
18233a31b7ebSMike Smith 				       sizeof(*ld->cl_lstatus))) != 0)
18243a31b7ebSMike Smith 	goto out;
18252fdaa90dSScott Long     cc = cr->cr_cc;
1826c6131460SPaul Saab     cc->header.address = *ld->cl_controller;	/* target controller */
18273a31b7ebSMike Smith     cbc = (struct ciss_bmic_cdb *)&(cc->cdb.cdb[0]);
1828c6131460SPaul Saab     cbc->log_drive = CISS_LUN_TO_TARGET(ld->cl_address.logical.lun);
18293a31b7ebSMike Smith 
18303a31b7ebSMike Smith     /*
18313a31b7ebSMike Smith      * Submit the request and wait for it to complete.
18323a31b7ebSMike Smith      */
18333a31b7ebSMike Smith     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
18343a31b7ebSMike Smith 	ciss_printf(sc, "error sending BMIC LSTATUS command (%d)\n", error);
18353a31b7ebSMike Smith 	goto out;
18363a31b7ebSMike Smith     }
18373a31b7ebSMike Smith 
18383a31b7ebSMike Smith     /*
18393a31b7ebSMike Smith      * Check response.
18403a31b7ebSMike Smith      */
18413a31b7ebSMike Smith     ciss_report_request(cr, &command_status, NULL);
18423a31b7ebSMike Smith     switch(command_status) {
18433a31b7ebSMike Smith     case CISS_CMD_STATUS_SUCCESS:		/* buffer right size */
18443a31b7ebSMike Smith 	break;
18453a31b7ebSMike Smith     case CISS_CMD_STATUS_DATA_UNDERRUN:
18463a31b7ebSMike Smith     case CISS_CMD_STATUS_DATA_OVERRUN:
18473a31b7ebSMike Smith 	ciss_printf(sc, "data over/underrun reading logical drive status\n");
18483a31b7ebSMike Smith     default:
18493a31b7ebSMike Smith 	ciss_printf(sc, "error reading logical drive status (%s)\n",
18503a31b7ebSMike Smith 		    ciss_name_command_status(command_status));
18513a31b7ebSMike Smith 	error = EIO;
18523a31b7ebSMike Smith 	goto out;
18533a31b7ebSMike Smith     }
18543a31b7ebSMike Smith 
18553a31b7ebSMike Smith     /*
18563a31b7ebSMike Smith      * Set the drive's summary status based on the returned status.
18573a31b7ebSMike Smith      *
18583a31b7ebSMike Smith      * XXX testing shows that a failed JBOD drive comes back at next
18593a31b7ebSMike Smith      * boot in "queued for expansion" mode.  WTF?
18603a31b7ebSMike Smith      */
18613a31b7ebSMike Smith     ld->cl_status = ciss_decode_ldrive_status(ld->cl_lstatus->status);
18623a31b7ebSMike Smith 
18633a31b7ebSMike Smith out:
18643a31b7ebSMike Smith     if (cr != NULL)
18653a31b7ebSMike Smith 	ciss_release_request(cr);
18663a31b7ebSMike Smith     return(error);
18673a31b7ebSMike Smith }
18683a31b7ebSMike Smith 
18693a31b7ebSMike Smith /************************************************************************
18703a31b7ebSMike Smith  * Notify the adapter of a config update.
18713a31b7ebSMike Smith  */
18723a31b7ebSMike Smith static int
18733a31b7ebSMike Smith ciss_update_config(struct ciss_softc *sc)
18743a31b7ebSMike Smith {
18753a31b7ebSMike Smith     int		i;
18763a31b7ebSMike Smith 
18773a31b7ebSMike Smith     debug_called(1);
18783a31b7ebSMike Smith 
18793a31b7ebSMike Smith     CISS_TL_SIMPLE_WRITE(sc, CISS_TL_SIMPLE_IDBR, CISS_TL_SIMPLE_IDBR_CFG_TABLE);
18803a31b7ebSMike Smith     for (i = 0; i < 1000; i++) {
18813a31b7ebSMike Smith 	if (!(CISS_TL_SIMPLE_READ(sc, CISS_TL_SIMPLE_IDBR) &
18823a31b7ebSMike Smith 	      CISS_TL_SIMPLE_IDBR_CFG_TABLE)) {
18833a31b7ebSMike Smith 	    return(0);
18843a31b7ebSMike Smith 	}
18853a31b7ebSMike Smith 	DELAY(1000);
18863a31b7ebSMike Smith     }
18873a31b7ebSMike Smith     return(1);
18883a31b7ebSMike Smith }
18893a31b7ebSMike Smith 
18903a31b7ebSMike Smith /************************************************************************
18913a31b7ebSMike Smith  * Accept new media into a logical drive.
18923a31b7ebSMike Smith  *
18933a31b7ebSMike Smith  * XXX The drive has previously been offline; it would be good if we
18943a31b7ebSMike Smith  *     could make sure it's not open right now.
18953a31b7ebSMike Smith  */
18963a31b7ebSMike Smith static int
189788c78a38SPaul Saab ciss_accept_media(struct ciss_softc *sc, struct ciss_ldrive *ld)
18983a31b7ebSMike Smith {
18993a31b7ebSMike Smith     struct ciss_request		*cr;
19003a31b7ebSMike Smith     struct ciss_command		*cc;
19013a31b7ebSMike Smith     struct ciss_bmic_cdb	*cbc;
190288c78a38SPaul Saab     int				command_status;
190388c78a38SPaul Saab     int				error = 0, ldrive;
1904609caf8dSPaul Saab 
1905609caf8dSPaul Saab     ldrive = CISS_LUN_TO_TARGET(ld->cl_address.logical.lun);
19063a31b7ebSMike Smith 
19073ea59fd3SSean Bruno     debug(0, "bringing logical drive %d back online", ldrive);
19083a31b7ebSMike Smith 
19093a31b7ebSMike Smith     /*
19103a31b7ebSMike Smith      * Build a CISS BMIC command to bring the drive back online.
19113a31b7ebSMike Smith      */
19123a31b7ebSMike Smith     if ((error = ciss_get_bmic_request(sc, &cr, CISS_BMIC_ACCEPT_MEDIA,
19133a31b7ebSMike Smith 				       NULL, 0)) != 0)
19143a31b7ebSMike Smith 	goto out;
19152fdaa90dSScott Long     cc = cr->cr_cc;
1916c6131460SPaul Saab     cc->header.address = *ld->cl_controller;	/* target controller */
19173a31b7ebSMike Smith     cbc = (struct ciss_bmic_cdb *)&(cc->cdb.cdb[0]);
1918609caf8dSPaul Saab     cbc->log_drive = ldrive;
19193a31b7ebSMike Smith 
19203a31b7ebSMike Smith     /*
19213a31b7ebSMike Smith      * Submit the request and wait for it to complete.
19223a31b7ebSMike Smith      */
19233a31b7ebSMike Smith     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
192488c78a38SPaul Saab 	ciss_printf(sc, "error sending BMIC ACCEPT MEDIA command (%d)\n", error);
19253a31b7ebSMike Smith 	goto out;
19263a31b7ebSMike Smith     }
19273a31b7ebSMike Smith 
19283a31b7ebSMike Smith     /*
19293a31b7ebSMike Smith      * Check response.
19303a31b7ebSMike Smith      */
19313a31b7ebSMike Smith     ciss_report_request(cr, &command_status, NULL);
19323a31b7ebSMike Smith     switch(command_status) {
19333a31b7ebSMike Smith     case CISS_CMD_STATUS_SUCCESS:		/* all OK */
19343a31b7ebSMike Smith 	/* we should get a logical drive status changed event here */
19353a31b7ebSMike Smith 	break;
19363a31b7ebSMike Smith     default:
19373a31b7ebSMike Smith 	ciss_printf(cr->cr_sc, "error accepting media into failed logical drive (%s)\n",
19383a31b7ebSMike Smith 		    ciss_name_command_status(command_status));
19393a31b7ebSMike Smith 	break;
19403a31b7ebSMike Smith     }
194188c78a38SPaul Saab 
194288c78a38SPaul Saab out:
194388c78a38SPaul Saab     if (cr != NULL)
19443a31b7ebSMike Smith 	ciss_release_request(cr);
194588c78a38SPaul Saab     return(error);
19463a31b7ebSMike Smith }
19473a31b7ebSMike Smith 
19483a31b7ebSMike Smith /************************************************************************
19493a31b7ebSMike Smith  * Release adapter resources.
19503a31b7ebSMike Smith  */
19513a31b7ebSMike Smith static void
19523a31b7ebSMike Smith ciss_free(struct ciss_softc *sc)
19533a31b7ebSMike Smith {
19543284b9eeSPaul Saab     struct ciss_request *cr;
1955ee626b40SPaul Saab     int			i, j;
19563284b9eeSPaul Saab 
19573a31b7ebSMike Smith     debug_called(1);
19583a31b7ebSMike Smith 
19593a31b7ebSMike Smith     /* we're going away */
19603a31b7ebSMike Smith     sc->ciss_flags |= CISS_FLAG_ABORTING;
19613a31b7ebSMike Smith 
19623a31b7ebSMike Smith     /* terminate the periodic heartbeat routine */
19632472e51eSScott Long     callout_stop(&sc->ciss_periodic);
19643a31b7ebSMike Smith 
19653a31b7ebSMike Smith     /* cancel the Event Notify chain */
19663a31b7ebSMike Smith     ciss_notify_abort(sc);
19673a31b7ebSMike Smith 
1968c6131460SPaul Saab     ciss_kill_notify_thread(sc);
1969c6131460SPaul Saab 
19702472e51eSScott Long     /* disconnect from CAM */
19712472e51eSScott Long     if (sc->ciss_cam_sim) {
19722472e51eSScott Long 	for (i = 0; i < sc->ciss_max_logical_bus; i++) {
19732472e51eSScott Long 	    if (sc->ciss_cam_sim[i]) {
19742472e51eSScott Long 		xpt_bus_deregister(cam_sim_path(sc->ciss_cam_sim[i]));
19752472e51eSScott Long 		cam_sim_free(sc->ciss_cam_sim[i], 0);
19762472e51eSScott Long 	    }
19772472e51eSScott Long 	}
19782472e51eSScott Long 	for (i = CISS_PHYSICAL_BASE; i < sc->ciss_max_physical_bus +
19792472e51eSScott Long 	     CISS_PHYSICAL_BASE; i++) {
19802472e51eSScott Long 	    if (sc->ciss_cam_sim[i]) {
19812472e51eSScott Long 		xpt_bus_deregister(cam_sim_path(sc->ciss_cam_sim[i]));
19822472e51eSScott Long 		cam_sim_free(sc->ciss_cam_sim[i], 0);
19832472e51eSScott Long 	    }
19842472e51eSScott Long 	}
19852472e51eSScott Long 	free(sc->ciss_cam_sim, CISS_MALLOC_CLASS);
19862472e51eSScott Long     }
19872472e51eSScott Long     if (sc->ciss_cam_devq)
19882472e51eSScott Long 	cam_simq_free(sc->ciss_cam_devq);
19892472e51eSScott Long 
199078d03361SPaul Saab     /* remove the control device */
19912472e51eSScott Long     mtx_unlock(&sc->ciss_mtx);
199278d03361SPaul Saab     if (sc->ciss_dev_t != NULL)
199378d03361SPaul Saab 	destroy_dev(sc->ciss_dev_t);
199478d03361SPaul Saab 
19952472e51eSScott Long     /* Final cleanup of the callout. */
19962472e51eSScott Long     callout_drain(&sc->ciss_periodic);
19972472e51eSScott Long     mtx_destroy(&sc->ciss_mtx);
19982472e51eSScott Long 
19993a31b7ebSMike Smith     /* free the controller data */
20003a31b7ebSMike Smith     if (sc->ciss_id != NULL)
20013a31b7ebSMike Smith 	free(sc->ciss_id, CISS_MALLOC_CLASS);
20023a31b7ebSMike Smith 
20033a31b7ebSMike Smith     /* release I/O resources */
20043a31b7ebSMike Smith     if (sc->ciss_regs_resource != NULL)
20053a31b7ebSMike Smith 	bus_release_resource(sc->ciss_dev, SYS_RES_MEMORY,
20063a31b7ebSMike Smith 			     sc->ciss_regs_rid, sc->ciss_regs_resource);
20073a31b7ebSMike Smith     if (sc->ciss_cfg_resource != NULL)
20083a31b7ebSMike Smith 	bus_release_resource(sc->ciss_dev, SYS_RES_MEMORY,
20093a31b7ebSMike Smith 			     sc->ciss_cfg_rid, sc->ciss_cfg_resource);
20103a31b7ebSMike Smith     if (sc->ciss_intr != NULL)
20113a31b7ebSMike Smith 	bus_teardown_intr(sc->ciss_dev, sc->ciss_irq_resource, sc->ciss_intr);
20123a31b7ebSMike Smith     if (sc->ciss_irq_resource != NULL)
20133a31b7ebSMike Smith 	bus_release_resource(sc->ciss_dev, SYS_RES_IRQ,
201422657ce1SScott Long 			     sc->ciss_irq_rid[0], sc->ciss_irq_resource);
201522657ce1SScott Long     if (sc->ciss_msi)
201622657ce1SScott Long 	pci_release_msi(sc->ciss_dev);
20173284b9eeSPaul Saab 
20183284b9eeSPaul Saab     while ((cr = ciss_dequeue_free(sc)) != NULL)
20193284b9eeSPaul Saab 	bus_dmamap_destroy(sc->ciss_buffer_dmat, cr->cr_datamap);
20203a31b7ebSMike Smith     if (sc->ciss_buffer_dmat)
20213a31b7ebSMike Smith 	bus_dma_tag_destroy(sc->ciss_buffer_dmat);
20223a31b7ebSMike Smith 
20233a31b7ebSMike Smith     /* destroy command memory and DMA tag */
20243a31b7ebSMike Smith     if (sc->ciss_command != NULL) {
20253a31b7ebSMike Smith 	bus_dmamap_unload(sc->ciss_command_dmat, sc->ciss_command_map);
20263a31b7ebSMike Smith 	bus_dmamem_free(sc->ciss_command_dmat, sc->ciss_command, sc->ciss_command_map);
20273a31b7ebSMike Smith     }
20283284b9eeSPaul Saab     if (sc->ciss_command_dmat)
20293a31b7ebSMike Smith 	bus_dma_tag_destroy(sc->ciss_command_dmat);
20303a31b7ebSMike Smith 
203122657ce1SScott Long     if (sc->ciss_reply) {
203222657ce1SScott Long 	bus_dmamap_unload(sc->ciss_reply_dmat, sc->ciss_reply_map);
203322657ce1SScott Long 	bus_dmamem_free(sc->ciss_reply_dmat, sc->ciss_reply, sc->ciss_reply_map);
203422657ce1SScott Long     }
203522657ce1SScott Long     if (sc->ciss_reply_dmat)
203622657ce1SScott Long 	bus_dma_tag_destroy(sc->ciss_reply_dmat);
203722657ce1SScott Long 
203822657ce1SScott Long     /* destroy DMA tags */
203922657ce1SScott Long     if (sc->ciss_parent_dmat)
204022657ce1SScott Long 	bus_dma_tag_destroy(sc->ciss_parent_dmat);
2041c6131460SPaul Saab     if (sc->ciss_logical) {
20425eae46afSConrad Meyer 	for (i = 0; i < sc->ciss_max_logical_bus; i++) {
2043e3edca22SSean Bruno 	    for (j = 0; j < sc->ciss_cfg->max_logical_supported; j++) {
2044ee626b40SPaul Saab 		if (sc->ciss_logical[i][j].cl_ldrive)
2045ee626b40SPaul Saab 		    free(sc->ciss_logical[i][j].cl_ldrive, CISS_MALLOC_CLASS);
2046ee626b40SPaul Saab 		if (sc->ciss_logical[i][j].cl_lstatus)
2047ee626b40SPaul Saab 		    free(sc->ciss_logical[i][j].cl_lstatus, CISS_MALLOC_CLASS);
2048ee626b40SPaul Saab 	    }
2049c6131460SPaul Saab 	    free(sc->ciss_logical[i], CISS_MALLOC_CLASS);
2050ee626b40SPaul Saab 	}
2051c6131460SPaul Saab 	free(sc->ciss_logical, CISS_MALLOC_CLASS);
2052c6131460SPaul Saab     }
2053c6131460SPaul Saab 
20541fe6c4eeSScott Long     if (sc->ciss_physical) {
20551fe6c4eeSScott Long 	for (i = 0; i < sc->ciss_max_physical_bus; i++)
20561fe6c4eeSScott Long 	    free(sc->ciss_physical[i], CISS_MALLOC_CLASS);
20571fe6c4eeSScott Long 	free(sc->ciss_physical, CISS_MALLOC_CLASS);
20581fe6c4eeSScott Long     }
20591fe6c4eeSScott Long 
2060c6131460SPaul Saab     if (sc->ciss_controllers)
2061c6131460SPaul Saab 	free(sc->ciss_controllers, CISS_MALLOC_CLASS);
2062975b7318SScott Long 
20633a31b7ebSMike Smith }
20643a31b7ebSMike Smith 
20653a31b7ebSMike Smith /************************************************************************
20663a31b7ebSMike Smith  * Give a command to the adapter.
20673a31b7ebSMike Smith  *
20683a31b7ebSMike Smith  * Note that this uses the simple transport layer directly.  If we
20693a31b7ebSMike Smith  * want to add support for other layers, we'll need a switch of some
20703a31b7ebSMike Smith  * sort.
20713a31b7ebSMike Smith  *
20723a31b7ebSMike Smith  * Note that the simple transport layer has no way of refusing a
20733a31b7ebSMike Smith  * command; we only have as many request structures as the adapter
20743a31b7ebSMike Smith  * supports commands, so we don't have to check (this presumes that
20753a31b7ebSMike Smith  * the adapter can handle commands as fast as we throw them at it).
20763a31b7ebSMike Smith  */
20773a31b7ebSMike Smith static int
20783a31b7ebSMike Smith ciss_start(struct ciss_request *cr)
20793a31b7ebSMike Smith {
20803a31b7ebSMike Smith     struct ciss_command	*cc;	/* XXX debugging only */
20813a31b7ebSMike Smith     int			error;
20823a31b7ebSMike Smith 
20832fdaa90dSScott Long     cc = cr->cr_cc;
20843a31b7ebSMike Smith     debug(2, "post command %d tag %d ", cr->cr_tag, cc->header.host_tag);
20853a31b7ebSMike Smith 
20863a31b7ebSMike Smith     /*
20873a31b7ebSMike Smith      * Map the request's data.
20883a31b7ebSMike Smith      */
20893a31b7ebSMike Smith     if ((error = ciss_map_request(cr)))
20903a31b7ebSMike Smith 	return(error);
20913a31b7ebSMike Smith 
20923a31b7ebSMike Smith #if 0
20933a31b7ebSMike Smith     ciss_print_request(cr);
20943a31b7ebSMike Smith #endif
20953a31b7ebSMike Smith 
20963a31b7ebSMike Smith     return(0);
20973a31b7ebSMike Smith }
20983a31b7ebSMike Smith 
20993a31b7ebSMike Smith /************************************************************************
21003a31b7ebSMike Smith  * Fetch completed request(s) from the adapter, queue them for
21013a31b7ebSMike Smith  * completion handling.
21023a31b7ebSMike Smith  *
21033a31b7ebSMike Smith  * Note that this uses the simple transport layer directly.  If we
21043a31b7ebSMike Smith  * want to add support for other layers, we'll need a switch of some
21053a31b7ebSMike Smith  * sort.
21063a31b7ebSMike Smith  *
21073a31b7ebSMike Smith  * Note that the simple transport mechanism does not require any
21083a31b7ebSMike Smith  * reentrancy protection; the OPQ read is atomic.  If there is a
21093a31b7ebSMike Smith  * chance of a race with something else that might move the request
21103a31b7ebSMike Smith  * off the busy list, then we will have to lock against that
21113a31b7ebSMike Smith  * (eg. timeouts, etc.)
21123a31b7ebSMike Smith  */
21133a31b7ebSMike Smith static void
211422657ce1SScott Long ciss_done(struct ciss_softc *sc, cr_qhead_t *qh)
21153a31b7ebSMike Smith {
21163a31b7ebSMike Smith     struct ciss_request	*cr;
21173a31b7ebSMike Smith     struct ciss_command	*cc;
21183a31b7ebSMike Smith     u_int32_t		tag, index;
21193a31b7ebSMike Smith 
21203a31b7ebSMike Smith     debug_called(3);
21213a31b7ebSMike Smith 
21223a31b7ebSMike Smith     /*
21233a31b7ebSMike Smith      * Loop quickly taking requests from the adapter and moving them
212422657ce1SScott Long      * to the completed queue.
21253a31b7ebSMike Smith      */
21263a31b7ebSMike Smith     for (;;) {
21273a31b7ebSMike Smith 	tag = CISS_TL_SIMPLE_FETCH_CMD(sc);
21283a31b7ebSMike Smith 	if (tag == CISS_TL_SIMPLE_OPQ_EMPTY)
21293a31b7ebSMike Smith 	    break;
21303a31b7ebSMike Smith 	index = tag >> 2;
21313a31b7ebSMike Smith 	debug(2, "completed command %d%s", index,
21323a31b7ebSMike Smith 	      (tag & CISS_HDR_HOST_TAG_ERROR) ? " with error" : "");
21333a31b7ebSMike Smith 	if (index >= sc->ciss_max_requests) {
21343a31b7ebSMike Smith 	    ciss_printf(sc, "completed invalid request %d (0x%x)\n", index, tag);
21353a31b7ebSMike Smith 	    continue;
21363a31b7ebSMike Smith 	}
21373a31b7ebSMike Smith 	cr = &(sc->ciss_request[index]);
21382fdaa90dSScott Long 	cc = cr->cr_cc;
21393a31b7ebSMike Smith 	cc->header.host_tag = tag;	/* not updated by adapter */
214022657ce1SScott Long 	ciss_enqueue_complete(cr, qh);
21413a31b7ebSMike Smith     }
21423a31b7ebSMike Smith 
214322657ce1SScott Long }
214422657ce1SScott Long 
214522657ce1SScott Long static void
214622657ce1SScott Long ciss_perf_done(struct ciss_softc *sc, cr_qhead_t *qh)
214722657ce1SScott Long {
214822657ce1SScott Long     struct ciss_request	*cr;
214922657ce1SScott Long     struct ciss_command	*cc;
215022657ce1SScott Long     u_int32_t		tag, index;
215122657ce1SScott Long 
215222657ce1SScott Long     debug_called(3);
215322657ce1SScott Long 
21543a31b7ebSMike Smith     /*
215522657ce1SScott Long      * Loop quickly taking requests from the adapter and moving them
215622657ce1SScott Long      * to the completed queue.
21573a31b7ebSMike Smith      */
215822657ce1SScott Long     for (;;) {
215922657ce1SScott Long 	tag = sc->ciss_reply[sc->ciss_rqidx];
216022657ce1SScott Long 	if ((tag & CISS_CYCLE_MASK) != sc->ciss_cycle)
216122657ce1SScott Long 	    break;
216222657ce1SScott Long 	index = tag >> 2;
216322657ce1SScott Long 	debug(2, "completed command %d%s\n", index,
216422657ce1SScott Long 	      (tag & CISS_HDR_HOST_TAG_ERROR) ? " with error" : "");
216522657ce1SScott Long 	if (index < sc->ciss_max_requests) {
216622657ce1SScott Long 	    cr = &(sc->ciss_request[index]);
21672fdaa90dSScott Long 	    cc = cr->cr_cc;
216822657ce1SScott Long 	    cc->header.host_tag = tag;	/* not updated by adapter */
216922657ce1SScott Long 	    ciss_enqueue_complete(cr, qh);
217022657ce1SScott Long 	} else {
217122657ce1SScott Long 	    ciss_printf(sc, "completed invalid request %d (0x%x)\n", index, tag);
217222657ce1SScott Long 	}
217322657ce1SScott Long 	if (++sc->ciss_rqidx == sc->ciss_max_requests) {
217422657ce1SScott Long 	    sc->ciss_rqidx = 0;
217522657ce1SScott Long 	    sc->ciss_cycle ^= 1;
217622657ce1SScott Long 	}
217722657ce1SScott Long     }
217822657ce1SScott Long 
21793a31b7ebSMike Smith }
21803a31b7ebSMike Smith 
21813a31b7ebSMike Smith /************************************************************************
21823a31b7ebSMike Smith  * Take an interrupt from the adapter.
21833a31b7ebSMike Smith  */
21843a31b7ebSMike Smith static void
21853a31b7ebSMike Smith ciss_intr(void *arg)
21863a31b7ebSMike Smith {
218722657ce1SScott Long     cr_qhead_t qh;
21883a31b7ebSMike Smith     struct ciss_softc	*sc = (struct ciss_softc *)arg;
21893a31b7ebSMike Smith 
21903a31b7ebSMike Smith     /*
21913a31b7ebSMike Smith      * The only interrupt we recognise indicates that there are
21923a31b7ebSMike Smith      * entries in the outbound post queue.
21933a31b7ebSMike Smith      */
219422657ce1SScott Long     STAILQ_INIT(&qh);
219522657ce1SScott Long     ciss_done(sc, &qh);
2196975b7318SScott Long     mtx_lock(&sc->ciss_mtx);
219722657ce1SScott Long     ciss_complete(sc, &qh);
2198975b7318SScott Long     mtx_unlock(&sc->ciss_mtx);
21993a31b7ebSMike Smith }
22003a31b7ebSMike Smith 
220122657ce1SScott Long static void
220222657ce1SScott Long ciss_perf_intr(void *arg)
220322657ce1SScott Long {
220422657ce1SScott Long     struct ciss_softc	*sc = (struct ciss_softc *)arg;
220522657ce1SScott Long 
220622657ce1SScott Long     /* Clear the interrupt and flush the bridges.  Docs say that the flush
220722657ce1SScott Long      * needs to be done twice, which doesn't seem right.
220822657ce1SScott Long      */
220922657ce1SScott Long     CISS_TL_PERF_CLEAR_INT(sc);
221022657ce1SScott Long     CISS_TL_PERF_FLUSH_INT(sc);
221122657ce1SScott Long 
221222657ce1SScott Long     ciss_perf_msi_intr(sc);
221322657ce1SScott Long }
221422657ce1SScott Long 
221522657ce1SScott Long static void
221622657ce1SScott Long ciss_perf_msi_intr(void *arg)
221722657ce1SScott Long {
221822657ce1SScott Long     cr_qhead_t qh;
221922657ce1SScott Long     struct ciss_softc	*sc = (struct ciss_softc *)arg;
222022657ce1SScott Long 
222122657ce1SScott Long     STAILQ_INIT(&qh);
222222657ce1SScott Long     ciss_perf_done(sc, &qh);
222322657ce1SScott Long     mtx_lock(&sc->ciss_mtx);
222422657ce1SScott Long     ciss_complete(sc, &qh);
222522657ce1SScott Long     mtx_unlock(&sc->ciss_mtx);
222622657ce1SScott Long }
222722657ce1SScott Long 
22283a31b7ebSMike Smith /************************************************************************
22293a31b7ebSMike Smith  * Process completed requests.
22303a31b7ebSMike Smith  *
22313a31b7ebSMike Smith  * Requests can be completed in three fashions:
22323a31b7ebSMike Smith  *
22333a31b7ebSMike Smith  * - by invoking a callback function (cr_complete is non-null)
22343a31b7ebSMike Smith  * - by waking up a sleeper (cr_flags has CISS_REQ_SLEEP set)
22353a31b7ebSMike Smith  * - by clearing the CISS_REQ_POLL flag in interrupt/timeout context
22363a31b7ebSMike Smith  */
22373a31b7ebSMike Smith static void
223822657ce1SScott Long ciss_complete(struct ciss_softc *sc, cr_qhead_t *qh)
22393a31b7ebSMike Smith {
22403a31b7ebSMike Smith     struct ciss_request	*cr;
22413a31b7ebSMike Smith 
22423a31b7ebSMike Smith     debug_called(2);
22433a31b7ebSMike Smith 
22443a31b7ebSMike Smith     /*
22453a31b7ebSMike Smith      * Loop taking requests off the completed queue and performing
22463a31b7ebSMike Smith      * completion processing on them.
22473a31b7ebSMike Smith      */
22483a31b7ebSMike Smith     for (;;) {
224922657ce1SScott Long 	if ((cr = ciss_dequeue_complete(sc, qh)) == NULL)
22503a31b7ebSMike Smith 	    break;
22513a31b7ebSMike Smith 	ciss_unmap_request(cr);
22523a31b7ebSMike Smith 
225322657ce1SScott Long 	if ((cr->cr_flags & CISS_REQ_BUSY) == 0)
225422657ce1SScott Long 	    ciss_printf(sc, "WARNING: completing non-busy request\n");
225522657ce1SScott Long 	cr->cr_flags &= ~CISS_REQ_BUSY;
225622657ce1SScott Long 
22573a31b7ebSMike Smith 	/*
22583a31b7ebSMike Smith 	 * If the request has a callback, invoke it.
22593a31b7ebSMike Smith 	 */
22603a31b7ebSMike Smith 	if (cr->cr_complete != NULL) {
22613a31b7ebSMike Smith 	    cr->cr_complete(cr);
22623a31b7ebSMike Smith 	    continue;
22633a31b7ebSMike Smith 	}
22643a31b7ebSMike Smith 
22653a31b7ebSMike Smith 	/*
22663a31b7ebSMike Smith 	 * If someone is sleeping on this request, wake them up.
22673a31b7ebSMike Smith 	 */
22683a31b7ebSMike Smith 	if (cr->cr_flags & CISS_REQ_SLEEP) {
22693a31b7ebSMike Smith 	    cr->cr_flags &= ~CISS_REQ_SLEEP;
22703a31b7ebSMike Smith 	    wakeup(cr);
22713a31b7ebSMike Smith 	    continue;
22723a31b7ebSMike Smith 	}
22733a31b7ebSMike Smith 
22743a31b7ebSMike Smith 	/*
22753a31b7ebSMike Smith 	 * If someone is polling this request for completion, signal.
22763a31b7ebSMike Smith 	 */
22773a31b7ebSMike Smith 	if (cr->cr_flags & CISS_REQ_POLL) {
22783a31b7ebSMike Smith 	    cr->cr_flags &= ~CISS_REQ_POLL;
22793a31b7ebSMike Smith 	    continue;
22803a31b7ebSMike Smith 	}
22813a31b7ebSMike Smith 
22823a31b7ebSMike Smith 	/*
22833a31b7ebSMike Smith 	 * Give up and throw the request back on the free queue.  This
22843a31b7ebSMike Smith 	 * should never happen; resources will probably be lost.
22853a31b7ebSMike Smith 	 */
22863a31b7ebSMike Smith 	ciss_printf(sc, "WARNING: completed command with no submitter\n");
22873a31b7ebSMike Smith 	ciss_enqueue_free(cr);
22883a31b7ebSMike Smith     }
22893a31b7ebSMike Smith }
22903a31b7ebSMike Smith 
22913a31b7ebSMike Smith /************************************************************************
22923a31b7ebSMike Smith  * Report on the completion status of a request, and pass back SCSI
22933a31b7ebSMike Smith  * and command status values.
22943a31b7ebSMike Smith  */
22953a31b7ebSMike Smith static int
229622657ce1SScott Long _ciss_report_request(struct ciss_request *cr, int *command_status, int *scsi_status, const char *func)
22973a31b7ebSMike Smith {
22983a31b7ebSMike Smith     struct ciss_command		*cc;
22993a31b7ebSMike Smith     struct ciss_error_info	*ce;
23003a31b7ebSMike Smith 
23013a31b7ebSMike Smith     debug_called(2);
23023a31b7ebSMike Smith 
23032fdaa90dSScott Long     cc = cr->cr_cc;
23043a31b7ebSMike Smith     ce = (struct ciss_error_info *)&(cc->sg[0]);
23053a31b7ebSMike Smith 
23063a31b7ebSMike Smith     /*
23073a31b7ebSMike Smith      * We don't consider data under/overrun an error for the Report
23083a31b7ebSMike Smith      * Logical/Physical LUNs commands.
23093a31b7ebSMike Smith      */
23103a31b7ebSMike Smith     if ((cc->header.host_tag & CISS_HDR_HOST_TAG_ERROR) &&
23112514c5bfSPaul Saab 	((ce->command_status == CISS_CMD_STATUS_DATA_OVERRUN) ||
23122514c5bfSPaul Saab 	 (ce->command_status == CISS_CMD_STATUS_DATA_UNDERRUN)) &&
23133a31b7ebSMike Smith 	((cc->cdb.cdb[0] == CISS_OPCODE_REPORT_LOGICAL_LUNS) ||
23142514c5bfSPaul Saab 	 (cc->cdb.cdb[0] == CISS_OPCODE_REPORT_PHYSICAL_LUNS) ||
23152514c5bfSPaul Saab 	 (cc->cdb.cdb[0] == INQUIRY))) {
23163a31b7ebSMike Smith 	cc->header.host_tag &= ~CISS_HDR_HOST_TAG_ERROR;
23173a31b7ebSMike Smith 	debug(2, "ignoring irrelevant under/overrun error");
23183a31b7ebSMike Smith     }
23193a31b7ebSMike Smith 
23203a31b7ebSMike Smith     /*
23213a31b7ebSMike Smith      * Check the command's error bit, if clear, there's no status and
23223a31b7ebSMike Smith      * everything is OK.
23233a31b7ebSMike Smith      */
23243a31b7ebSMike Smith     if (!(cc->header.host_tag & CISS_HDR_HOST_TAG_ERROR)) {
23253a31b7ebSMike Smith 	if (scsi_status != NULL)
23263a31b7ebSMike Smith 	    *scsi_status = SCSI_STATUS_OK;
23273a31b7ebSMike Smith 	if (command_status != NULL)
23283a31b7ebSMike Smith 	    *command_status = CISS_CMD_STATUS_SUCCESS;
23293a31b7ebSMike Smith 	return(0);
23303a31b7ebSMike Smith     } else {
23313a31b7ebSMike Smith 	if (command_status != NULL)
23323a31b7ebSMike Smith 	    *command_status = ce->command_status;
23333a31b7ebSMike Smith 	if (scsi_status != NULL) {
2334e8144a13SAlexander Motin 	    if (ce->command_status == CISS_CMD_STATUS_DATA_UNDERRUN) {
2335e8144a13SAlexander Motin 		*scsi_status = SCSI_STATUS_OK;
2336e8144a13SAlexander Motin 	    } else if (ce->command_status == CISS_CMD_STATUS_TARGET_STATUS) {
23373a31b7ebSMike Smith 		*scsi_status = ce->scsi_status;
23383a31b7ebSMike Smith 	    } else {
23393a31b7ebSMike Smith 		*scsi_status = -1;
23403a31b7ebSMike Smith 	    }
23413a31b7ebSMike Smith 	}
2342e8144a13SAlexander Motin 	if (bootverbose && ce->command_status != CISS_CMD_STATUS_DATA_UNDERRUN)
23433a31b7ebSMike Smith 	    ciss_printf(cr->cr_sc, "command status 0x%x (%s) scsi status 0x%x\n",
23443a31b7ebSMike Smith 			ce->command_status, ciss_name_command_status(ce->command_status),
23453a31b7ebSMike Smith 			ce->scsi_status);
23463a31b7ebSMike Smith 	if (ce->command_status == CISS_CMD_STATUS_INVALID_COMMAND) {
234722657ce1SScott Long 	    ciss_printf(cr->cr_sc, "invalid command, offense size %d at %d, value 0x%x, function %s\n",
23483a31b7ebSMike Smith 			ce->additional_error_info.invalid_command.offense_size,
23493a31b7ebSMike Smith 			ce->additional_error_info.invalid_command.offense_offset,
235022657ce1SScott Long 			ce->additional_error_info.invalid_command.offense_value,
235122657ce1SScott Long 			func);
23523a31b7ebSMike Smith 	}
23533a31b7ebSMike Smith     }
2354c6131460SPaul Saab #if 0
2355c6131460SPaul Saab     ciss_print_request(cr);
2356c6131460SPaul Saab #endif
23573a31b7ebSMike Smith     return(1);
23583a31b7ebSMike Smith }
23593a31b7ebSMike Smith 
23603a31b7ebSMike Smith /************************************************************************
23613a31b7ebSMike Smith  * Issue a request and don't return until it's completed.
23623a31b7ebSMike Smith  *
23633a31b7ebSMike Smith  * Depending on adapter status, we may poll or sleep waiting for
23643a31b7ebSMike Smith  * completion.
23653a31b7ebSMike Smith  */
23663a31b7ebSMike Smith static int
23673a31b7ebSMike Smith ciss_synch_request(struct ciss_request *cr, int timeout)
23683a31b7ebSMike Smith {
23693a31b7ebSMike Smith     if (cr->cr_sc->ciss_flags & CISS_FLAG_RUNNING) {
23703a31b7ebSMike Smith 	return(ciss_wait_request(cr, timeout));
23713a31b7ebSMike Smith     } else {
23723a31b7ebSMike Smith 	return(ciss_poll_request(cr, timeout));
23733a31b7ebSMike Smith     }
23743a31b7ebSMike Smith }
23753a31b7ebSMike Smith 
23763a31b7ebSMike Smith /************************************************************************
23773a31b7ebSMike Smith  * Issue a request and poll for completion.
23783a31b7ebSMike Smith  *
23793a31b7ebSMike Smith  * Timeout in milliseconds.
23803a31b7ebSMike Smith  */
23813a31b7ebSMike Smith static int
23823a31b7ebSMike Smith ciss_poll_request(struct ciss_request *cr, int timeout)
23833a31b7ebSMike Smith {
238422657ce1SScott Long     cr_qhead_t qh;
238522657ce1SScott Long     struct ciss_softc *sc;
23863a31b7ebSMike Smith     int		error;
23873a31b7ebSMike Smith 
23883a31b7ebSMike Smith     debug_called(2);
23893a31b7ebSMike Smith 
239022657ce1SScott Long     STAILQ_INIT(&qh);
239122657ce1SScott Long     sc = cr->cr_sc;
23923a31b7ebSMike Smith     cr->cr_flags |= CISS_REQ_POLL;
23933a31b7ebSMike Smith     if ((error = ciss_start(cr)) != 0)
23943a31b7ebSMike Smith 	return(error);
23953a31b7ebSMike Smith 
23963a31b7ebSMike Smith     do {
239722657ce1SScott Long 	if (sc->ciss_perf)
239822657ce1SScott Long 	    ciss_perf_done(sc, &qh);
239922657ce1SScott Long 	else
240022657ce1SScott Long 	    ciss_done(sc, &qh);
240122657ce1SScott Long 	ciss_complete(sc, &qh);
24023a31b7ebSMike Smith 	if (!(cr->cr_flags & CISS_REQ_POLL))
24033a31b7ebSMike Smith 	    return(0);
24043a31b7ebSMike Smith 	DELAY(1000);
24053a31b7ebSMike Smith     } while (timeout-- >= 0);
24063a31b7ebSMike Smith     return(EWOULDBLOCK);
24073a31b7ebSMike Smith }
24083a31b7ebSMike Smith 
24093a31b7ebSMike Smith /************************************************************************
24103a31b7ebSMike Smith  * Issue a request and sleep waiting for completion.
24113a31b7ebSMike Smith  *
24123a31b7ebSMike Smith  * Timeout in milliseconds.  Note that a spurious wakeup will reset
24133a31b7ebSMike Smith  * the timeout.
24143a31b7ebSMike Smith  */
24153a31b7ebSMike Smith static int
24163a31b7ebSMike Smith ciss_wait_request(struct ciss_request *cr, int timeout)
24173a31b7ebSMike Smith {
241822657ce1SScott Long     int		error;
24193a31b7ebSMike Smith 
24203a31b7ebSMike Smith     debug_called(2);
24213a31b7ebSMike Smith 
24223a31b7ebSMike Smith     cr->cr_flags |= CISS_REQ_SLEEP;
24233a31b7ebSMike Smith     if ((error = ciss_start(cr)) != 0)
24243a31b7ebSMike Smith 	return(error);
24253a31b7ebSMike Smith 
242640f05b02SPaul Saab     while ((cr->cr_flags & CISS_REQ_SLEEP) && (error != EWOULDBLOCK)) {
242785c9dd9dSSteven Hartland 	error = msleep_sbt(cr, &cr->cr_sc->ciss_mtx, PRIBIO, "cissREQ",
242885c9dd9dSSteven Hartland 	    SBT_1MS * timeout, 0, 0);
24293a31b7ebSMike Smith     }
24303a31b7ebSMike Smith     return(error);
24313a31b7ebSMike Smith }
24323a31b7ebSMike Smith 
24336197ca15SPeter Wemm #if 0
24343a31b7ebSMike Smith /************************************************************************
24353a31b7ebSMike Smith  * Abort a request.  Note that a potential exists here to race the
24363a31b7ebSMike Smith  * request being completed; the caller must deal with this.
24373a31b7ebSMike Smith  */
24383a31b7ebSMike Smith static int
24393a31b7ebSMike Smith ciss_abort_request(struct ciss_request *ar)
24403a31b7ebSMike Smith {
24413a31b7ebSMike Smith     struct ciss_request		*cr;
24423a31b7ebSMike Smith     struct ciss_command		*cc;
24433a31b7ebSMike Smith     struct ciss_message_cdb	*cmc;
24443a31b7ebSMike Smith     int				error;
24453a31b7ebSMike Smith 
24463a31b7ebSMike Smith     debug_called(1);
24473a31b7ebSMike Smith 
24483a31b7ebSMike Smith     /* get a request */
24493a31b7ebSMike Smith     if ((error = ciss_get_request(ar->cr_sc, &cr)) != 0)
24503a31b7ebSMike Smith 	return(error);
24513a31b7ebSMike Smith 
24523a31b7ebSMike Smith     /* build the abort command */
24532fdaa90dSScott Long     cc = cr->cr_cc;
24543a31b7ebSMike Smith     cc->header.address.mode.mode = CISS_HDR_ADDRESS_MODE_PERIPHERAL;	/* addressing? */
24553a31b7ebSMike Smith     cc->header.address.physical.target = 0;
24563a31b7ebSMike Smith     cc->header.address.physical.bus = 0;
24573a31b7ebSMike Smith     cc->cdb.cdb_length = sizeof(*cmc);
24583a31b7ebSMike Smith     cc->cdb.type = CISS_CDB_TYPE_MESSAGE;
24593a31b7ebSMike Smith     cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;
24603a31b7ebSMike Smith     cc->cdb.direction = CISS_CDB_DIRECTION_NONE;
24613a31b7ebSMike Smith     cc->cdb.timeout = 30;
24623a31b7ebSMike Smith 
24633a31b7ebSMike Smith     cmc = (struct ciss_message_cdb *)&(cc->cdb.cdb[0]);
24643a31b7ebSMike Smith     cmc->opcode = CISS_OPCODE_MESSAGE_ABORT;
24653a31b7ebSMike Smith     cmc->type = CISS_MESSAGE_ABORT_TASK;
24663a31b7ebSMike Smith     cmc->abort_tag = ar->cr_tag;	/* endianness?? */
24673a31b7ebSMike Smith 
24683a31b7ebSMike Smith     /*
24693a31b7ebSMike Smith      * Send the request and wait for a response.  If we believe we
24703a31b7ebSMike Smith      * aborted the request OK, clear the flag that indicates it's
24713a31b7ebSMike Smith      * running.
24723a31b7ebSMike Smith      */
24733a31b7ebSMike Smith     error = ciss_synch_request(cr, 35 * 1000);
24743a31b7ebSMike Smith     if (!error)
24753a31b7ebSMike Smith 	error = ciss_report_request(cr, NULL, NULL);
24763a31b7ebSMike Smith     ciss_release_request(cr);
24773a31b7ebSMike Smith 
24783a31b7ebSMike Smith     return(error);
24793a31b7ebSMike Smith }
24806197ca15SPeter Wemm #endif
24813a31b7ebSMike Smith 
24823a31b7ebSMike Smith /************************************************************************
24833a31b7ebSMike Smith  * Fetch and initialise a request
24843a31b7ebSMike Smith  */
24853a31b7ebSMike Smith static int
24863a31b7ebSMike Smith ciss_get_request(struct ciss_softc *sc, struct ciss_request **crp)
24873a31b7ebSMike Smith {
24883a31b7ebSMike Smith     struct ciss_request *cr;
24893a31b7ebSMike Smith 
24903a31b7ebSMike Smith     debug_called(2);
24913a31b7ebSMike Smith 
24923a31b7ebSMike Smith     /*
24933a31b7ebSMike Smith      * Get a request and clean it up.
24943a31b7ebSMike Smith      */
24953a31b7ebSMike Smith     if ((cr = ciss_dequeue_free(sc)) == NULL)
24963a31b7ebSMike Smith 	return(ENOMEM);
24973a31b7ebSMike Smith 
24983a31b7ebSMike Smith     cr->cr_data = NULL;
24993a31b7ebSMike Smith     cr->cr_flags = 0;
25003a31b7ebSMike Smith     cr->cr_complete = NULL;
2501639717c8SPaul Saab     cr->cr_private = NULL;
250222657ce1SScott Long     cr->cr_sg_tag = CISS_SG_MAX;	/* Backstop to prevent accidents */
25033a31b7ebSMike Smith 
25043a31b7ebSMike Smith     ciss_preen_command(cr);
25053a31b7ebSMike Smith     *crp = cr;
25063a31b7ebSMike Smith     return(0);
25073a31b7ebSMike Smith }
25083a31b7ebSMike Smith 
25093a31b7ebSMike Smith static void
25103a31b7ebSMike Smith ciss_preen_command(struct ciss_request *cr)
25113a31b7ebSMike Smith {
25123a31b7ebSMike Smith     struct ciss_command	*cc;
25133a31b7ebSMike Smith     u_int32_t		cmdphys;
25143a31b7ebSMike Smith 
25153a31b7ebSMike Smith     /*
25163a31b7ebSMike Smith      * Clean up the command structure.
25173a31b7ebSMike Smith      *
25183a31b7ebSMike Smith      * Note that we set up the error_info structure here, since the
25193a31b7ebSMike Smith      * length can be overwritten by any command.
25203a31b7ebSMike Smith      */
25212fdaa90dSScott Long     cc = cr->cr_cc;
25223a31b7ebSMike Smith     cc->header.sg_in_list = 0;		/* kinda inefficient this way */
25233a31b7ebSMike Smith     cc->header.sg_total = 0;
25243a31b7ebSMike Smith     cc->header.host_tag = cr->cr_tag << 2;
25253a31b7ebSMike Smith     cc->header.host_tag_zeroes = 0;
25263d3ddb44SSean Bruno     bzero(&(cc->sg[0]), CISS_COMMAND_ALLOC_SIZE - sizeof(struct ciss_command));
25272fdaa90dSScott Long     cmdphys = cr->cr_ccphys;
25283a31b7ebSMike Smith     cc->error_info.error_info_address = cmdphys + sizeof(struct ciss_command);
25293a31b7ebSMike Smith     cc->error_info.error_info_length = CISS_COMMAND_ALLOC_SIZE - sizeof(struct ciss_command);
25303a31b7ebSMike Smith }
25313a31b7ebSMike Smith 
25323a31b7ebSMike Smith /************************************************************************
25333a31b7ebSMike Smith  * Release a request to the free list.
25343a31b7ebSMike Smith  */
25353a31b7ebSMike Smith static void
25363a31b7ebSMike Smith ciss_release_request(struct ciss_request *cr)
25373a31b7ebSMike Smith {
25383a31b7ebSMike Smith     struct ciss_softc	*sc;
25393a31b7ebSMike Smith 
25403a31b7ebSMike Smith     debug_called(2);
25413a31b7ebSMike Smith 
25423a31b7ebSMike Smith     sc = cr->cr_sc;
25433a31b7ebSMike Smith 
25443a31b7ebSMike Smith     /* release the request to the free queue */
25453a31b7ebSMike Smith     ciss_requeue_free(cr);
25463a31b7ebSMike Smith }
25473a31b7ebSMike Smith 
25483a31b7ebSMike Smith /************************************************************************
25493a31b7ebSMike Smith  * Allocate a request that will be used to send a BMIC command.  Do some
25503a31b7ebSMike Smith  * of the common setup here to avoid duplicating it everywhere else.
25513a31b7ebSMike Smith  */
25523a31b7ebSMike Smith static int
25533a31b7ebSMike Smith ciss_get_bmic_request(struct ciss_softc *sc, struct ciss_request **crp,
25543a31b7ebSMike Smith 		      int opcode, void **bufp, size_t bufsize)
25553a31b7ebSMike Smith {
25563a31b7ebSMike Smith     struct ciss_request		*cr;
25573a31b7ebSMike Smith     struct ciss_command		*cc;
25583a31b7ebSMike Smith     struct ciss_bmic_cdb	*cbc;
25593a31b7ebSMike Smith     void			*buf;
25603a31b7ebSMike Smith     int				error;
25613a31b7ebSMike Smith     int				dataout;
25623a31b7ebSMike Smith 
25633a31b7ebSMike Smith     debug_called(2);
25643a31b7ebSMike Smith 
25653a31b7ebSMike Smith     cr = NULL;
25663a31b7ebSMike Smith     buf = NULL;
25673a31b7ebSMike Smith 
25683a31b7ebSMike Smith     /*
25693a31b7ebSMike Smith      * Get a request.
25703a31b7ebSMike Smith      */
25713a31b7ebSMike Smith     if ((error = ciss_get_request(sc, &cr)) != 0)
25723a31b7ebSMike Smith 	goto out;
25733a31b7ebSMike Smith 
25743a31b7ebSMike Smith     /*
25753a31b7ebSMike Smith      * Allocate data storage if requested, determine the data direction.
25763a31b7ebSMike Smith      */
25773a31b7ebSMike Smith     dataout = 0;
25783a31b7ebSMike Smith     if ((bufsize > 0) && (bufp != NULL)) {
25793a31b7ebSMike Smith 	if (*bufp == NULL) {
25803a31b7ebSMike Smith 	    if ((buf = malloc(bufsize, CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO)) == NULL) {
25813a31b7ebSMike Smith 		error = ENOMEM;
25823a31b7ebSMike Smith 		goto out;
25833a31b7ebSMike Smith 	    }
25843a31b7ebSMike Smith 	} else {
25853a31b7ebSMike Smith 	    buf = *bufp;
25863a31b7ebSMike Smith 	    dataout = 1;	/* we are given a buffer, so we are writing */
25873a31b7ebSMike Smith 	}
25883a31b7ebSMike Smith     }
25893a31b7ebSMike Smith 
25903a31b7ebSMike Smith     /*
25913a31b7ebSMike Smith      * Build a CISS BMIC command to get the logical drive ID.
25923a31b7ebSMike Smith      */
25933a31b7ebSMike Smith     cr->cr_data = buf;
25943a31b7ebSMike Smith     cr->cr_length = bufsize;
25953a31b7ebSMike Smith     if (!dataout)
25963a31b7ebSMike Smith 	cr->cr_flags = CISS_REQ_DATAIN;
25973a31b7ebSMike Smith 
25982fdaa90dSScott Long     cc = cr->cr_cc;
25993a31b7ebSMike Smith     cc->header.address.physical.mode = CISS_HDR_ADDRESS_MODE_PERIPHERAL;
26003a31b7ebSMike Smith     cc->header.address.physical.bus = 0;
26013a31b7ebSMike Smith     cc->header.address.physical.target = 0;
26023a31b7ebSMike Smith     cc->cdb.cdb_length = sizeof(*cbc);
26033a31b7ebSMike Smith     cc->cdb.type = CISS_CDB_TYPE_COMMAND;
26043a31b7ebSMike Smith     cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;
26053a31b7ebSMike Smith     cc->cdb.direction = dataout ? CISS_CDB_DIRECTION_WRITE : CISS_CDB_DIRECTION_READ;
26063a31b7ebSMike Smith     cc->cdb.timeout = 0;
26073a31b7ebSMike Smith 
26083a31b7ebSMike Smith     cbc = (struct ciss_bmic_cdb *)&(cc->cdb.cdb[0]);
26093a31b7ebSMike Smith     bzero(cbc, sizeof(*cbc));
26103a31b7ebSMike Smith     cbc->opcode = dataout ? CISS_ARRAY_CONTROLLER_WRITE : CISS_ARRAY_CONTROLLER_READ;
26113a31b7ebSMike Smith     cbc->bmic_opcode = opcode;
26123a31b7ebSMike Smith     cbc->size = htons((u_int16_t)bufsize);
26133a31b7ebSMike Smith 
26143a31b7ebSMike Smith out:
26153a31b7ebSMike Smith     if (error) {
26163a31b7ebSMike Smith 	if (cr != NULL)
26173a31b7ebSMike Smith 	    ciss_release_request(cr);
26183a31b7ebSMike Smith     } else {
26193a31b7ebSMike Smith 	*crp = cr;
26203a31b7ebSMike Smith 	if ((bufp != NULL) && (*bufp == NULL) && (buf != NULL))
26213a31b7ebSMike Smith 	    *bufp = buf;
26223a31b7ebSMike Smith     }
26233a31b7ebSMike Smith     return(error);
26243a31b7ebSMike Smith }
26253a31b7ebSMike Smith 
26263a31b7ebSMike Smith /************************************************************************
26273a31b7ebSMike Smith  * Handle a command passed in from userspace.
26283a31b7ebSMike Smith  */
26293a31b7ebSMike Smith static int
26303a31b7ebSMike Smith ciss_user_command(struct ciss_softc *sc, IOCTL_Command_struct *ioc)
26313a31b7ebSMike Smith {
26323a31b7ebSMike Smith     struct ciss_request		*cr;
26333a31b7ebSMike Smith     struct ciss_command		*cc;
26343a31b7ebSMike Smith     struct ciss_error_info	*ce;
26353c63a8b4SPaul Saab     int				error = 0;
26363a31b7ebSMike Smith 
26373a31b7ebSMike Smith     debug_called(1);
26383a31b7ebSMike Smith 
26393a31b7ebSMike Smith     cr = NULL;
26403a31b7ebSMike Smith 
26413a31b7ebSMike Smith     /*
26423a31b7ebSMike Smith      * Get a request.
26433a31b7ebSMike Smith      */
2644f83695f5SPaul Saab     while (ciss_get_request(sc, &cr) != 0)
2645975b7318SScott Long 	msleep(sc, &sc->ciss_mtx, PPAUSE, "cissREQ", hz);
26462fdaa90dSScott Long     cc = cr->cr_cc;
26473a31b7ebSMike Smith 
26483a31b7ebSMike Smith     /*
26493a31b7ebSMike Smith      * Allocate an in-kernel databuffer if required, copy in user data.
26503a31b7ebSMike Smith      */
2651744c0d23SScott Long     mtx_unlock(&sc->ciss_mtx);
26523a31b7ebSMike Smith     cr->cr_length = ioc->buf_size;
26533a31b7ebSMike Smith     if (ioc->buf_size > 0) {
2654975b7318SScott Long 	if ((cr->cr_data = malloc(ioc->buf_size, CISS_MALLOC_CLASS, M_NOWAIT)) == NULL) {
26553a31b7ebSMike Smith 	    error = ENOMEM;
2656744c0d23SScott Long 	    goto out_unlocked;
26573a31b7ebSMike Smith 	}
26583a31b7ebSMike Smith 	if ((error = copyin(ioc->buf, cr->cr_data, ioc->buf_size))) {
26593a31b7ebSMike Smith 	    debug(0, "copyin: bad data buffer %p/%d", ioc->buf, ioc->buf_size);
2660744c0d23SScott Long 	    goto out_unlocked;
26613a31b7ebSMike Smith 	}
26623a31b7ebSMike Smith     }
26633a31b7ebSMike Smith 
26643a31b7ebSMike Smith     /*
26653a31b7ebSMike Smith      * Build the request based on the user command.
26663a31b7ebSMike Smith      */
26673a31b7ebSMike Smith     bcopy(&ioc->LUN_info, &cc->header.address, sizeof(cc->header.address));
26683a31b7ebSMike Smith     bcopy(&ioc->Request, &cc->cdb, sizeof(cc->cdb));
26693a31b7ebSMike Smith 
26703a31b7ebSMike Smith     /* XXX anything else to populate here? */
2671744c0d23SScott Long     mtx_lock(&sc->ciss_mtx);
26723a31b7ebSMike Smith 
26733a31b7ebSMike Smith     /*
26743a31b7ebSMike Smith      * Run the command.
26753a31b7ebSMike Smith      */
26763a31b7ebSMike Smith     if ((error = ciss_synch_request(cr, 60 * 1000))) {
26773a31b7ebSMike Smith 	debug(0, "request failed - %d", error);
26783a31b7ebSMike Smith 	goto out;
26793a31b7ebSMike Smith     }
26803a31b7ebSMike Smith 
26813a31b7ebSMike Smith     /*
26823c63a8b4SPaul Saab      * Check to see if the command succeeded.
26833a31b7ebSMike Smith      */
26843a31b7ebSMike Smith     ce = (struct ciss_error_info *)&(cc->sg[0]);
26853c6b8353SPaul Saab     if ((cc->header.host_tag & CISS_HDR_HOST_TAG_ERROR) == 0)
26863c63a8b4SPaul Saab 	bzero(ce, sizeof(*ce));
26873c63a8b4SPaul Saab 
26883c63a8b4SPaul Saab     /*
26893c63a8b4SPaul Saab      * Copy the results back to the user.
26903c63a8b4SPaul Saab      */
26913a31b7ebSMike Smith     bcopy(ce, &ioc->error_info, sizeof(*ce));
2692744c0d23SScott Long     mtx_unlock(&sc->ciss_mtx);
26933a31b7ebSMike Smith     if ((ioc->buf_size > 0) &&
26943a31b7ebSMike Smith 	(error = copyout(cr->cr_data, ioc->buf, ioc->buf_size))) {
26953a31b7ebSMike Smith 	debug(0, "copyout: bad data buffer %p/%d", ioc->buf, ioc->buf_size);
2696744c0d23SScott Long 	goto out_unlocked;
26973a31b7ebSMike Smith     }
26983a31b7ebSMike Smith 
26993a31b7ebSMike Smith     /* done OK */
27003a31b7ebSMike Smith     error = 0;
27013a31b7ebSMike Smith 
2702744c0d23SScott Long out_unlocked:
2703744c0d23SScott Long     mtx_lock(&sc->ciss_mtx);
2704744c0d23SScott Long 
27053a31b7ebSMike Smith out:
27063a31b7ebSMike Smith     if ((cr != NULL) && (cr->cr_data != NULL))
27073a31b7ebSMike Smith 	free(cr->cr_data, CISS_MALLOC_CLASS);
27083a31b7ebSMike Smith     if (cr != NULL)
27093a31b7ebSMike Smith 	ciss_release_request(cr);
27103a31b7ebSMike Smith     return(error);
27113a31b7ebSMike Smith }
27123a31b7ebSMike Smith 
27133a31b7ebSMike Smith /************************************************************************
27143a31b7ebSMike Smith  * Map a request into bus-visible space, initialise the scatter/gather
27153a31b7ebSMike Smith  * list.
27163a31b7ebSMike Smith  */
27173a31b7ebSMike Smith static int
27183a31b7ebSMike Smith ciss_map_request(struct ciss_request *cr)
27193a31b7ebSMike Smith {
27203a31b7ebSMike Smith     struct ciss_softc	*sc;
2721639717c8SPaul Saab     int			error = 0;
27223a31b7ebSMike Smith 
27233a31b7ebSMike Smith     debug_called(2);
27243a31b7ebSMike Smith 
27253a31b7ebSMike Smith     sc = cr->cr_sc;
27263a31b7ebSMike Smith 
27273a31b7ebSMike Smith     /* check that mapping is necessary */
2728639717c8SPaul Saab     if (cr->cr_flags & CISS_REQ_MAPPED)
27293a31b7ebSMike Smith 	return(0);
27303a31b7ebSMike Smith 
27313a31b7ebSMike Smith     cr->cr_flags |= CISS_REQ_MAPPED;
2732639717c8SPaul Saab 
2733639717c8SPaul Saab     bus_dmamap_sync(sc->ciss_command_dmat, sc->ciss_command_map,
2734639717c8SPaul Saab 		    BUS_DMASYNC_PREWRITE);
2735639717c8SPaul Saab 
2736639717c8SPaul Saab     if (cr->cr_data != NULL) {
2737dd0b4fb6SKonstantin Belousov 	if (cr->cr_flags & CISS_REQ_CCB)
2738dd0b4fb6SKonstantin Belousov 		error = bus_dmamap_load_ccb(sc->ciss_buffer_dmat,
2739dd0b4fb6SKonstantin Belousov 					cr->cr_datamap, cr->cr_data,
2740dd0b4fb6SKonstantin Belousov 					ciss_request_map_helper, cr, 0);
2741dd0b4fb6SKonstantin Belousov 	else
2742639717c8SPaul Saab 		error = bus_dmamap_load(sc->ciss_buffer_dmat, cr->cr_datamap,
2743639717c8SPaul Saab 					cr->cr_data, cr->cr_length,
2744639717c8SPaul Saab 					ciss_request_map_helper, cr, 0);
2745639717c8SPaul Saab 	if (error != 0)
2746639717c8SPaul Saab 	    return (error);
2747639717c8SPaul Saab     } else {
2748639717c8SPaul Saab 	/*
2749639717c8SPaul Saab 	 * Post the command to the adapter.
2750639717c8SPaul Saab 	 */
275122657ce1SScott Long 	cr->cr_sg_tag = CISS_SG_NONE;
275222657ce1SScott Long 	cr->cr_flags |= CISS_REQ_BUSY;
275322657ce1SScott Long 	if (sc->ciss_perf)
275422657ce1SScott Long 	    CISS_TL_PERF_POST_CMD(sc, cr);
275522657ce1SScott Long 	else
27562fdaa90dSScott Long 	    CISS_TL_SIMPLE_POST_CMD(sc, cr->cr_ccphys);
2757639717c8SPaul Saab     }
2758639717c8SPaul Saab 
27593a31b7ebSMike Smith     return(0);
27603a31b7ebSMike Smith }
27613a31b7ebSMike Smith 
27623a31b7ebSMike Smith static void
27633a31b7ebSMike Smith ciss_request_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
27643a31b7ebSMike Smith {
27653a31b7ebSMike Smith     struct ciss_command	*cc;
2766639717c8SPaul Saab     struct ciss_request *cr;
2767639717c8SPaul Saab     struct ciss_softc	*sc;
27683a31b7ebSMike Smith     int			i;
27693a31b7ebSMike Smith 
27703a31b7ebSMike Smith     debug_called(2);
27713a31b7ebSMike Smith 
2772639717c8SPaul Saab     cr = (struct ciss_request *)arg;
2773639717c8SPaul Saab     sc = cr->cr_sc;
27742fdaa90dSScott Long     cc = cr->cr_cc;
2775639717c8SPaul Saab 
27763a31b7ebSMike Smith     for (i = 0; i < nseg; i++) {
27773a31b7ebSMike Smith 	cc->sg[i].address = segs[i].ds_addr;
27783a31b7ebSMike Smith 	cc->sg[i].length = segs[i].ds_len;
27793a31b7ebSMike Smith 	cc->sg[i].extension = 0;
27803a31b7ebSMike Smith     }
27813a31b7ebSMike Smith     /* we leave the s/g table entirely within the command */
27823a31b7ebSMike Smith     cc->header.sg_in_list = nseg;
27833a31b7ebSMike Smith     cc->header.sg_total = nseg;
2784639717c8SPaul Saab 
2785639717c8SPaul Saab     if (cr->cr_flags & CISS_REQ_DATAIN)
2786639717c8SPaul Saab 	bus_dmamap_sync(sc->ciss_buffer_dmat, cr->cr_datamap, BUS_DMASYNC_PREREAD);
2787639717c8SPaul Saab     if (cr->cr_flags & CISS_REQ_DATAOUT)
2788639717c8SPaul Saab 	bus_dmamap_sync(sc->ciss_buffer_dmat, cr->cr_datamap, BUS_DMASYNC_PREWRITE);
2789639717c8SPaul Saab 
279062fdee1dSScott Long     if (nseg == 0)
279122657ce1SScott Long 	cr->cr_sg_tag = CISS_SG_NONE;
279222657ce1SScott Long     else if (nseg == 1)
279322657ce1SScott Long 	cr->cr_sg_tag = CISS_SG_1;
279422657ce1SScott Long     else if (nseg == 2)
279522657ce1SScott Long 	cr->cr_sg_tag = CISS_SG_2;
279622657ce1SScott Long     else if (nseg <= 4)
279722657ce1SScott Long 	cr->cr_sg_tag = CISS_SG_4;
279822657ce1SScott Long     else if (nseg <= 8)
279922657ce1SScott Long 	cr->cr_sg_tag = CISS_SG_8;
280022657ce1SScott Long     else if (nseg <= 16)
280122657ce1SScott Long 	cr->cr_sg_tag = CISS_SG_16;
280222657ce1SScott Long     else if (nseg <= 32)
280322657ce1SScott Long 	cr->cr_sg_tag = CISS_SG_32;
280422657ce1SScott Long     else
280522657ce1SScott Long 	cr->cr_sg_tag = CISS_SG_MAX;
280622657ce1SScott Long 
2807639717c8SPaul Saab     /*
2808639717c8SPaul Saab      * Post the command to the adapter.
2809639717c8SPaul Saab      */
281022657ce1SScott Long     cr->cr_flags |= CISS_REQ_BUSY;
281122657ce1SScott Long     if (sc->ciss_perf)
281222657ce1SScott Long 	CISS_TL_PERF_POST_CMD(sc, cr);
281322657ce1SScott Long     else
28142fdaa90dSScott Long 	CISS_TL_SIMPLE_POST_CMD(sc, cr->cr_ccphys);
28153a31b7ebSMike Smith }
28163a31b7ebSMike Smith 
28173a31b7ebSMike Smith /************************************************************************
28183a31b7ebSMike Smith  * Unmap a request from bus-visible space.
28193a31b7ebSMike Smith  */
28203a31b7ebSMike Smith static void
28213a31b7ebSMike Smith ciss_unmap_request(struct ciss_request *cr)
28223a31b7ebSMike Smith {
28233a31b7ebSMike Smith     struct ciss_softc	*sc;
28243a31b7ebSMike Smith 
28253a31b7ebSMike Smith     debug_called(2);
28263a31b7ebSMike Smith 
28273a31b7ebSMike Smith     sc = cr->cr_sc;
28283a31b7ebSMike Smith 
28293a31b7ebSMike Smith     /* check that unmapping is necessary */
2830639717c8SPaul Saab     if ((cr->cr_flags & CISS_REQ_MAPPED) == 0)
28313a31b7ebSMike Smith 	return;
28323a31b7ebSMike Smith 
2833639717c8SPaul Saab     bus_dmamap_sync(sc->ciss_command_dmat, sc->ciss_command_map,
2834639717c8SPaul Saab 		    BUS_DMASYNC_POSTWRITE);
2835639717c8SPaul Saab 
2836639717c8SPaul Saab     if (cr->cr_data == NULL)
2837639717c8SPaul Saab 	goto out;
2838639717c8SPaul Saab 
28393a31b7ebSMike Smith     if (cr->cr_flags & CISS_REQ_DATAIN)
28403a31b7ebSMike Smith 	bus_dmamap_sync(sc->ciss_buffer_dmat, cr->cr_datamap, BUS_DMASYNC_POSTREAD);
28413a31b7ebSMike Smith     if (cr->cr_flags & CISS_REQ_DATAOUT)
28423a31b7ebSMike Smith 	bus_dmamap_sync(sc->ciss_buffer_dmat, cr->cr_datamap, BUS_DMASYNC_POSTWRITE);
28433a31b7ebSMike Smith 
28443a31b7ebSMike Smith     bus_dmamap_unload(sc->ciss_buffer_dmat, cr->cr_datamap);
2845639717c8SPaul Saab out:
28463a31b7ebSMike Smith     cr->cr_flags &= ~CISS_REQ_MAPPED;
28473a31b7ebSMike Smith }
28483a31b7ebSMike Smith 
28493a31b7ebSMike Smith /************************************************************************
28503a31b7ebSMike Smith  * Attach the driver to CAM.
28513a31b7ebSMike Smith  *
28523a31b7ebSMike Smith  * We put all the logical drives on a single SCSI bus.
28533a31b7ebSMike Smith  */
28543a31b7ebSMike Smith static int
28553a31b7ebSMike Smith ciss_cam_init(struct ciss_softc *sc)
28563a31b7ebSMike Smith {
28571fe6c4eeSScott Long     int			i, maxbus;
28583a31b7ebSMike Smith 
28593a31b7ebSMike Smith     debug_called(1);
28603a31b7ebSMike Smith 
28613a31b7ebSMike Smith     /*
28623a31b7ebSMike Smith      * Allocate a devq.  We can reuse this for the masked physical
28633a31b7ebSMike Smith      * devices if we decide to export these as well.
28643a31b7ebSMike Smith      */
286595dab4f2SAlexander Motin     if ((sc->ciss_cam_devq = cam_simq_alloc(sc->ciss_max_requests - 2)) == NULL) {
28663a31b7ebSMike Smith 	ciss_printf(sc, "can't allocate CAM SIM queue\n");
28673a31b7ebSMike Smith 	return(ENOMEM);
28683a31b7ebSMike Smith     }
28693a31b7ebSMike Smith 
28703a31b7ebSMike Smith     /*
28713a31b7ebSMike Smith      * Create a SIM.
28721fe6c4eeSScott Long      *
28731fe6c4eeSScott Long      * This naturally wastes a bit of memory.  The alternative is to allocate
28741fe6c4eeSScott Long      * and register each bus as it is found, and then track them on a linked
28751fe6c4eeSScott Long      * list.  Unfortunately, the driver has a few places where it needs to
28761fe6c4eeSScott Long      * look up the SIM based solely on bus number, and it's unclear whether
28771fe6c4eeSScott Long      * a list traversal would work for these situations.
28783a31b7ebSMike Smith      */
28791fe6c4eeSScott Long     maxbus = max(sc->ciss_max_logical_bus, sc->ciss_max_physical_bus +
28801fe6c4eeSScott Long 		 CISS_PHYSICAL_BASE);
2881ac2fffa4SPedro F. Giffuni     sc->ciss_cam_sim = malloc(maxbus * sizeof(struct cam_sim*),
2882c6131460SPaul Saab 			      CISS_MALLOC_CLASS, M_NOWAIT | M_ZERO);
2883c6131460SPaul Saab     if (sc->ciss_cam_sim == NULL) {
2884c6131460SPaul Saab 	ciss_printf(sc, "can't allocate memory for controller SIM\n");
2885c6131460SPaul Saab 	return(ENOMEM);
2886c6131460SPaul Saab     }
2887c6131460SPaul Saab 
28881fe6c4eeSScott Long     for (i = 0; i < sc->ciss_max_logical_bus; i++) {
2889c6131460SPaul Saab 	if ((sc->ciss_cam_sim[i] = cam_sim_alloc(ciss_cam_action, ciss_cam_poll,
2890c6131460SPaul Saab 						 "ciss", sc,
28912aa6b972SPaul Saab 						 device_get_unit(sc->ciss_dev),
289245650f52SScott Long 						 &sc->ciss_mtx,
289322657ce1SScott Long 						 2,
2894d4aa427fSPaul Saab 						 sc->ciss_max_requests - 2,
28953a31b7ebSMike Smith 						 sc->ciss_cam_devq)) == NULL) {
2896c6131460SPaul Saab 	    ciss_printf(sc, "can't allocate CAM SIM for controller %d\n", i);
28973a31b7ebSMike Smith 	    return(ENOMEM);
28983a31b7ebSMike Smith 	}
28993a31b7ebSMike Smith 
29003a31b7ebSMike Smith 	/*
2901c6131460SPaul Saab 	 * Register bus with this SIM.
29023a31b7ebSMike Smith 	 */
2903975b7318SScott Long 	mtx_lock(&sc->ciss_mtx);
29041fe6c4eeSScott Long 	if (i == 0 || sc->ciss_controllers[i].physical.bus != 0) {
2905b50569b7SScott Long 	    if (xpt_bus_register(sc->ciss_cam_sim[i], sc->ciss_dev, i) != 0) {
29061fe6c4eeSScott Long 		ciss_printf(sc, "can't register SCSI bus %d\n", i);
2907975b7318SScott Long 		mtx_unlock(&sc->ciss_mtx);
29081fe6c4eeSScott Long 		return (ENXIO);
29091fe6c4eeSScott Long 	    }
29101fe6c4eeSScott Long 	}
2911975b7318SScott Long 	mtx_unlock(&sc->ciss_mtx);
29121fe6c4eeSScott Long     }
29131fe6c4eeSScott Long 
29141fe6c4eeSScott Long     for (i = CISS_PHYSICAL_BASE; i < sc->ciss_max_physical_bus +
29151fe6c4eeSScott Long 	 CISS_PHYSICAL_BASE; i++) {
29161fe6c4eeSScott Long 	if ((sc->ciss_cam_sim[i] = cam_sim_alloc(ciss_cam_action, ciss_cam_poll,
29171fe6c4eeSScott Long 						 "ciss", sc,
29181fe6c4eeSScott Long 						 device_get_unit(sc->ciss_dev),
2919975b7318SScott Long 						 &sc->ciss_mtx, 1,
29201fe6c4eeSScott Long 						 sc->ciss_max_requests - 2,
29211fe6c4eeSScott Long 						 sc->ciss_cam_devq)) == NULL) {
29221fe6c4eeSScott Long 	    ciss_printf(sc, "can't allocate CAM SIM for controller %d\n", i);
29231fe6c4eeSScott Long 	    return (ENOMEM);
29241fe6c4eeSScott Long 	}
29251fe6c4eeSScott Long 
2926975b7318SScott Long 	mtx_lock(&sc->ciss_mtx);
2927b50569b7SScott Long 	if (xpt_bus_register(sc->ciss_cam_sim[i], sc->ciss_dev, i) != 0) {
2928c6131460SPaul Saab 	    ciss_printf(sc, "can't register SCSI bus %d\n", i);
2929975b7318SScott Long 	    mtx_unlock(&sc->ciss_mtx);
29303a31b7ebSMike Smith 	    return (ENXIO);
29313a31b7ebSMike Smith 	}
2932975b7318SScott Long 	mtx_unlock(&sc->ciss_mtx);
2933c6131460SPaul Saab     }
29343a31b7ebSMike Smith 
29353a31b7ebSMike Smith     return(0);
29363a31b7ebSMike Smith }
29373a31b7ebSMike Smith 
29383a31b7ebSMike Smith /************************************************************************
29393a31b7ebSMike Smith  * Initiate a rescan of the 'logical devices' SIM
29403a31b7ebSMike Smith  */
29413a31b7ebSMike Smith static void
2942c6131460SPaul Saab ciss_cam_rescan_target(struct ciss_softc *sc, int bus, int target)
29433a31b7ebSMike Smith {
29443a31b7ebSMike Smith     union ccb		*ccb;
29453a31b7ebSMike Smith 
29463a31b7ebSMike Smith     debug_called(1);
29473a31b7ebSMike Smith 
294883c5d981SAlexander Motin     if ((ccb = xpt_alloc_ccb_nowait()) == NULL) {
29493a31b7ebSMike Smith 	ciss_printf(sc, "rescan failed (can't allocate CCB)\n");
29503a31b7ebSMike Smith 	return;
29513a31b7ebSMike Smith     }
29523a31b7ebSMike Smith 
2953e5dfa058SAlexander Motin     if (xpt_create_path(&ccb->ccb_h.path, NULL,
295483c5d981SAlexander Motin 	    cam_sim_path(sc->ciss_cam_sim[bus]),
2955c6131460SPaul Saab 	    target, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
29563a31b7ebSMike Smith 	ciss_printf(sc, "rescan failed (can't create path)\n");
295783c5d981SAlexander Motin 	xpt_free_ccb(ccb);
29583a31b7ebSMike Smith 	return;
29593a31b7ebSMike Smith     }
296083c5d981SAlexander Motin     xpt_rescan(ccb);
29613a31b7ebSMike Smith     /* scan is now in progress */
29623a31b7ebSMike Smith }
29633a31b7ebSMike Smith 
29643a31b7ebSMike Smith /************************************************************************
29653a31b7ebSMike Smith  * Handle requests coming from CAM
29663a31b7ebSMike Smith  */
29673a31b7ebSMike Smith static void
29683a31b7ebSMike Smith ciss_cam_action(struct cam_sim *sim, union ccb *ccb)
29693a31b7ebSMike Smith {
2970440baa08SPaul Saab     struct ciss_softc	*sc;
2971440baa08SPaul Saab     struct ccb_scsiio	*csio;
2972c6131460SPaul Saab     int			bus, target;
29731fe6c4eeSScott Long     int			physical;
2974440baa08SPaul Saab 
2975440baa08SPaul Saab     sc = cam_sim_softc(sim);
2976c6131460SPaul Saab     bus = cam_sim_bus(sim);
2977440baa08SPaul Saab     csio = (struct ccb_scsiio *)&ccb->csio;
2978440baa08SPaul Saab     target = csio->ccb_h.target_id;
29791fe6c4eeSScott Long     physical = CISS_IS_PHYSICAL(bus);
2980440baa08SPaul Saab 
29813a31b7ebSMike Smith     switch (ccb->ccb_h.func_code) {
29823a31b7ebSMike Smith 	/* perform SCSI I/O */
29833a31b7ebSMike Smith     case XPT_SCSI_IO:
2984440baa08SPaul Saab 	if (!ciss_cam_action_io(sim, csio))
29853a31b7ebSMike Smith 	    return;
29863a31b7ebSMike Smith 	break;
29873a31b7ebSMike Smith 
29883a31b7ebSMike Smith 	/* perform geometry calculations */
29893a31b7ebSMike Smith     case XPT_CALC_GEOMETRY:
29903a31b7ebSMike Smith     {
29913a31b7ebSMike Smith 	struct ccb_calc_geometry	*ccg = &ccb->ccg;
29921fe6c4eeSScott Long 	struct ciss_ldrive		*ld;
29933a31b7ebSMike Smith 
29943a31b7ebSMike Smith 	debug(1, "XPT_CALC_GEOMETRY %d:%d:%d", cam_sim_bus(sim), ccb->ccb_h.target_id, ccb->ccb_h.target_lun);
29953a31b7ebSMike Smith 
29961fe6c4eeSScott Long 	ld = NULL;
29971fe6c4eeSScott Long 	if (!physical)
29981fe6c4eeSScott Long 	    ld = &sc->ciss_logical[bus][target];
29991fe6c4eeSScott Long 
30003a31b7ebSMike Smith 	/*
3001440baa08SPaul Saab 	 * Use the cached geometry settings unless the fault tolerance
3002440baa08SPaul Saab 	 * is invalid.
30033a31b7ebSMike Smith 	 */
30041fe6c4eeSScott Long 	if (physical || ld->cl_geometry.fault_tolerance == 0xFF) {
3005440baa08SPaul Saab 	    u_int32_t			secs_per_cylinder;
3006440baa08SPaul Saab 
30073a31b7ebSMike Smith 	    ccg->heads = 255;
30083a31b7ebSMike Smith 	    ccg->secs_per_track = 32;
30093a31b7ebSMike Smith 	    secs_per_cylinder = ccg->heads * ccg->secs_per_track;
30103a31b7ebSMike Smith 	    ccg->cylinders = ccg->volume_size / secs_per_cylinder;
3011440baa08SPaul Saab 	} else {
3012440baa08SPaul Saab 	    ccg->heads = ld->cl_geometry.heads;
3013440baa08SPaul Saab 	    ccg->secs_per_track = ld->cl_geometry.sectors;
3014440baa08SPaul Saab 	    ccg->cylinders = ntohs(ld->cl_geometry.cylinders);
3015440baa08SPaul Saab 	}
30163a31b7ebSMike Smith 	ccb->ccb_h.status = CAM_REQ_CMP;
30173a31b7ebSMike Smith         break;
30183a31b7ebSMike Smith     }
30193a31b7ebSMike Smith 
30203a31b7ebSMike Smith 	/* handle path attribute inquiry */
30213a31b7ebSMike Smith     case XPT_PATH_INQ:
30223a31b7ebSMike Smith     {
30233a31b7ebSMike Smith 	struct ccb_pathinq	*cpi = &ccb->cpi;
3024bdde5705SSean Bruno 	int			sg_length;
30253a31b7ebSMike Smith 
30263a31b7ebSMike Smith 	debug(1, "XPT_PATH_INQ %d:%d:%d", cam_sim_bus(sim), ccb->ccb_h.target_id, ccb->ccb_h.target_lun);
30273a31b7ebSMike Smith 
30283a31b7ebSMike Smith 	cpi->version_num = 1;
30293a31b7ebSMike Smith 	cpi->hba_inquiry = PI_TAG_ABLE;	/* XXX is this correct? */
30303a31b7ebSMike Smith 	cpi->target_sprt = 0;
30313a31b7ebSMike Smith 	cpi->hba_misc = 0;
3032e3edca22SSean Bruno 	cpi->max_target = sc->ciss_cfg->max_logical_supported;
30333a31b7ebSMike Smith 	cpi->max_lun = 0;		/* 'logical drive' channel only */
3034e3edca22SSean Bruno 	cpi->initiator_id = sc->ciss_cfg->max_logical_supported;
30354195c7deSAlan Somers 	strlcpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
30364195c7deSAlan Somers 	strlcpy(cpi->hba_vid, "CISS", HBA_IDLEN);
30374195c7deSAlan Somers 	strlcpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
30383a31b7ebSMike Smith 	cpi->unit_number = cam_sim_unit(sim);
30393a31b7ebSMike Smith 	cpi->bus_id = cam_sim_bus(sim);
30403a31b7ebSMike Smith 	cpi->base_transfer_speed = 132 * 1024;	/* XXX what to set this to? */
3041fa9ed865SMatt Jacob 	cpi->transport = XPORT_SPI;
3042fa9ed865SMatt Jacob 	cpi->transport_version = 2;
3043fa9ed865SMatt Jacob 	cpi->protocol = PROTO_SCSI;
3044fa9ed865SMatt Jacob 	cpi->protocol_version = SCSI_REV_2;
3045bdde5705SSean Bruno 	if (sc->ciss_cfg->max_sg_length == 0) {
3046e8e4cdbaSSean Bruno 		sg_length = 17;
3047bdde5705SSean Bruno 	} else {
3048bdde5705SSean Bruno 	/* XXX Fix for ZMR cards that advertise max_sg_length == 32
3049bdde5705SSean Bruno 	 * Confusing bit here. max_sg_length is usually a power of 2. We always
3050bdde5705SSean Bruno 	 * need to subtract 1 to account for partial pages. Then we need to
3051bdde5705SSean Bruno 	 * align on a valid PAGE_SIZE so we round down to the nearest power of 2.
3052bdde5705SSean Bruno 	 * Add 1 so we can then subtract it out in the assignment to maxio.
3053bdde5705SSean Bruno 	 * The reason for all these shenanigans is to create a maxio value that
3054bdde5705SSean Bruno 	 * creates IO operations to volumes that yield consistent operations
3055bdde5705SSean Bruno 	 * with good performance.
3056bdde5705SSean Bruno 	 */
3057bdde5705SSean Bruno 		sg_length = sc->ciss_cfg->max_sg_length - 1;
3058bdde5705SSean Bruno 		sg_length = (1 << (fls(sg_length) - 1)) + 1;
3059bdde5705SSean Bruno 	}
3060bdde5705SSean Bruno 	cpi->maxio = (min(CISS_MAX_SG_ELEMENTS, sg_length) - 1) * PAGE_SIZE;
30613a31b7ebSMike Smith 	ccb->ccb_h.status = CAM_REQ_CMP;
30623a31b7ebSMike Smith 	break;
30633a31b7ebSMike Smith     }
30643a31b7ebSMike Smith 
30653a31b7ebSMike Smith     case XPT_GET_TRAN_SETTINGS:
30663a31b7ebSMike Smith     {
30673a31b7ebSMike Smith 	struct ccb_trans_settings	*cts = &ccb->cts;
30683a31b7ebSMike Smith 	int				bus, target;
306963b9228bSScott Long 	struct ccb_trans_settings_spi *spi = &cts->xport_specific.spi;
307063b9228bSScott Long 	struct ccb_trans_settings_scsi *scsi = &cts->proto_specific.scsi;
30713a31b7ebSMike Smith 
30723a31b7ebSMike Smith 	bus = cam_sim_bus(sim);
30733a31b7ebSMike Smith 	target = cts->ccb_h.target_id;
30743a31b7ebSMike Smith 
30753a31b7ebSMike Smith 	debug(1, "XPT_GET_TRAN_SETTINGS %d:%d", bus, target);
30763a31b7ebSMike Smith 	/* disconnect always OK */
3077fa9ed865SMatt Jacob 	cts->protocol = PROTO_SCSI;
3078fa9ed865SMatt Jacob 	cts->protocol_version = SCSI_REV_2;
3079fa9ed865SMatt Jacob 	cts->transport = XPORT_SPI;
3080fa9ed865SMatt Jacob 	cts->transport_version = 2;
3081fa9ed865SMatt Jacob 
3082fa9ed865SMatt Jacob 	spi->valid = CTS_SPI_VALID_DISC;
3083fa9ed865SMatt Jacob 	spi->flags = CTS_SPI_FLAGS_DISC_ENB;
30843a31b7ebSMike Smith 
308563b9228bSScott Long 	scsi->valid = CTS_SCSI_VALID_TQ;
308663b9228bSScott Long 	scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
308763b9228bSScott Long 
30883a31b7ebSMike Smith 	cts->ccb_h.status = CAM_REQ_CMP;
30893a31b7ebSMike Smith 	break;
30903a31b7ebSMike Smith     }
30913a31b7ebSMike Smith 
30923a31b7ebSMike Smith     default:		/* we can't do this */
30933a31b7ebSMike Smith 	debug(1, "unspported func_code = 0x%x", ccb->ccb_h.func_code);
30943a31b7ebSMike Smith 	ccb->ccb_h.status = CAM_REQ_INVALID;
30953a31b7ebSMike Smith 	break;
30963a31b7ebSMike Smith     }
30973a31b7ebSMike Smith 
30983a31b7ebSMike Smith     xpt_done(ccb);
30993a31b7ebSMike Smith }
31003a31b7ebSMike Smith 
31013a31b7ebSMike Smith /************************************************************************
31023a31b7ebSMike Smith  * Handle a CAM SCSI I/O request.
31033a31b7ebSMike Smith  */
31043a31b7ebSMike Smith static int
31053a31b7ebSMike Smith ciss_cam_action_io(struct cam_sim *sim, struct ccb_scsiio *csio)
31063a31b7ebSMike Smith {
31073a31b7ebSMike Smith     struct ciss_softc	*sc;
31083a31b7ebSMike Smith     int			bus, target;
31093a31b7ebSMike Smith     struct ciss_request	*cr;
31103a31b7ebSMike Smith     struct ciss_command	*cc;
31113a31b7ebSMike Smith     int			error;
31123a31b7ebSMike Smith 
31133a31b7ebSMike Smith     sc = cam_sim_softc(sim);
31143a31b7ebSMike Smith     bus = cam_sim_bus(sim);
31153a31b7ebSMike Smith     target = csio->ccb_h.target_id;
31163a31b7ebSMike Smith 
31173a31b7ebSMike Smith     debug(2, "XPT_SCSI_IO %d:%d:%d", bus, target, csio->ccb_h.target_lun);
31183a31b7ebSMike Smith 
31193a31b7ebSMike Smith     /* check that the CDB pointer is not to a physical address */
31203a31b7ebSMike Smith     if ((csio->ccb_h.flags & CAM_CDB_POINTER) && (csio->ccb_h.flags & CAM_CDB_PHYS)) {
31213a31b7ebSMike Smith 	debug(3, "  CDB pointer is to physical address");
31223a31b7ebSMike Smith 	csio->ccb_h.status = CAM_REQ_CMP_ERR;
31233a31b7ebSMike Smith     }
31243a31b7ebSMike Smith 
31253a31b7ebSMike Smith     /* abandon aborted ccbs or those that have failed validation */
31263a31b7ebSMike Smith     if ((csio->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_INPROG) {
31273a31b7ebSMike Smith 	debug(3, "abandoning CCB due to abort/validation failure");
31283a31b7ebSMike Smith 	return(EINVAL);
31293a31b7ebSMike Smith     }
31303a31b7ebSMike Smith 
31313a31b7ebSMike Smith     /* handle emulation of some SCSI commands ourself */
31323a31b7ebSMike Smith     if (ciss_cam_emulate(sc, csio))
31333a31b7ebSMike Smith 	return(0);
31343a31b7ebSMike Smith 
31353a31b7ebSMike Smith     /*
31363a31b7ebSMike Smith      * Get a request to manage this command.  If we can't, return the
31373a31b7ebSMike Smith      * ccb, freeze the queue and flag so that we unfreeze it when a
31383a31b7ebSMike Smith      * request completes.
31393a31b7ebSMike Smith      */
31403a31b7ebSMike Smith     if ((error = ciss_get_request(sc, &cr)) != 0) {
31411fe6c4eeSScott Long 	xpt_freeze_simq(sim, 1);
314295dab4f2SAlexander Motin 	sc->ciss_flags |= CISS_FLAG_BUSY;
31433a31b7ebSMike Smith 	csio->ccb_h.status |= CAM_REQUEUE_REQ;
31443a31b7ebSMike Smith 	return(error);
31453a31b7ebSMike Smith     }
31463a31b7ebSMike Smith 
31473a31b7ebSMike Smith     /*
31483a31b7ebSMike Smith      * Build the command.
31493a31b7ebSMike Smith      */
31502fdaa90dSScott Long     cc = cr->cr_cc;
3151dd0b4fb6SKonstantin Belousov     cr->cr_data = csio;
31523a31b7ebSMike Smith     cr->cr_length = csio->dxfer_len;
31533a31b7ebSMike Smith     cr->cr_complete = ciss_cam_complete;
31543a31b7ebSMike Smith     cr->cr_private = csio;
31553a31b7ebSMike Smith 
3156c6131460SPaul Saab     /*
3157c6131460SPaul Saab      * Target the right logical volume.
3158c6131460SPaul Saab      */
31591fe6c4eeSScott Long     if (CISS_IS_PHYSICAL(bus))
31601fe6c4eeSScott Long 	cc->header.address =
31611fe6c4eeSScott Long 	    sc->ciss_physical[CISS_CAM_TO_PBUS(bus)][target].cp_address;
31621fe6c4eeSScott Long     else
31631fe6c4eeSScott Long 	cc->header.address =
31641fe6c4eeSScott Long 	    sc->ciss_logical[bus][target].cl_address;
31653a31b7ebSMike Smith     cc->cdb.cdb_length = csio->cdb_len;
31663a31b7ebSMike Smith     cc->cdb.type = CISS_CDB_TYPE_COMMAND;
31673a31b7ebSMike Smith     cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;	/* XXX ordered tags? */
31683a31b7ebSMike Smith     if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT) {
3169dd0b4fb6SKonstantin Belousov 	cr->cr_flags = CISS_REQ_DATAOUT | CISS_REQ_CCB;
31703a31b7ebSMike Smith 	cc->cdb.direction = CISS_CDB_DIRECTION_WRITE;
31713a31b7ebSMike Smith     } else if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
3172dd0b4fb6SKonstantin Belousov 	cr->cr_flags = CISS_REQ_DATAIN | CISS_REQ_CCB;
31733a31b7ebSMike Smith 	cc->cdb.direction = CISS_CDB_DIRECTION_READ;
31743a31b7ebSMike Smith     } else {
3175dd0b4fb6SKonstantin Belousov 	cr->cr_data = NULL;
31763a31b7ebSMike Smith 	cr->cr_flags = 0;
31773a31b7ebSMike Smith 	cc->cdb.direction = CISS_CDB_DIRECTION_NONE;
31783a31b7ebSMike Smith     }
31793a31b7ebSMike Smith     cc->cdb.timeout = (csio->ccb_h.timeout / 1000) + 1;
31803a31b7ebSMike Smith     if (csio->ccb_h.flags & CAM_CDB_POINTER) {
31813a31b7ebSMike Smith 	bcopy(csio->cdb_io.cdb_ptr, &cc->cdb.cdb[0], csio->cdb_len);
31823a31b7ebSMike Smith     } else {
31833a31b7ebSMike Smith 	bcopy(csio->cdb_io.cdb_bytes, &cc->cdb.cdb[0], csio->cdb_len);
31843a31b7ebSMike Smith     }
31853a31b7ebSMike Smith 
31863a31b7ebSMike Smith     /*
31873a31b7ebSMike Smith      * Submit the request to the adapter.
31883a31b7ebSMike Smith      *
31893a31b7ebSMike Smith      * Note that this may fail if we're unable to map the request (and
31903a31b7ebSMike Smith      * if we ever learn a transport layer other than simple, may fail
31913a31b7ebSMike Smith      * if the adapter rejects the command).
31923a31b7ebSMike Smith      */
31933a31b7ebSMike Smith     if ((error = ciss_start(cr)) != 0) {
31941fe6c4eeSScott Long 	xpt_freeze_simq(sim, 1);
3195639717c8SPaul Saab 	csio->ccb_h.status |= CAM_RELEASE_SIMQ;
31960a65b79fSAlexander Motin 	if (error == EINPROGRESS) {
3197639717c8SPaul Saab 	    error = 0;
3198639717c8SPaul Saab 	} else {
31993a31b7ebSMike Smith 	    csio->ccb_h.status |= CAM_REQUEUE_REQ;
32003a31b7ebSMike Smith 	    ciss_release_request(cr);
3201639717c8SPaul Saab 	}
32023a31b7ebSMike Smith 	return(error);
32033a31b7ebSMike Smith     }
32043a31b7ebSMike Smith 
32053a31b7ebSMike Smith     return(0);
32063a31b7ebSMike Smith }
32073a31b7ebSMike Smith 
32083a31b7ebSMike Smith /************************************************************************
32093a31b7ebSMike Smith  * Emulate SCSI commands the adapter doesn't handle as we might like.
32103a31b7ebSMike Smith  */
32113a31b7ebSMike Smith static int
32123a31b7ebSMike Smith ciss_cam_emulate(struct ciss_softc *sc, struct ccb_scsiio *csio)
32133a31b7ebSMike Smith {
3214c6131460SPaul Saab     int		bus, target;
32153a31b7ebSMike Smith     u_int8_t	opcode;
32163a31b7ebSMike Smith 
32173a31b7ebSMike Smith     target = csio->ccb_h.target_id;
3218c6131460SPaul Saab     bus = cam_sim_bus(xpt_path_sim(csio->ccb_h.path));
32193a31b7ebSMike Smith     opcode = (csio->ccb_h.flags & CAM_CDB_POINTER) ?
32203a31b7ebSMike Smith 	*(u_int8_t *)csio->cdb_io.cdb_ptr : csio->cdb_io.cdb_bytes[0];
32213a31b7ebSMike Smith 
32221fe6c4eeSScott Long     if (CISS_IS_PHYSICAL(bus)) {
32231fe6c4eeSScott Long 	if (sc->ciss_physical[CISS_CAM_TO_PBUS(bus)][target].cp_online != 1) {
32240a65b79fSAlexander Motin 	    csio->ccb_h.status |= CAM_SEL_TIMEOUT;
32251fe6c4eeSScott Long 	    xpt_done((union ccb *)csio);
32261fe6c4eeSScott Long 	    return(1);
32271fe6c4eeSScott Long 	} else
32281fe6c4eeSScott Long 	    return(0);
32291fe6c4eeSScott Long     }
32301fe6c4eeSScott Long 
32313a31b7ebSMike Smith     /*
32326f71a953SPaul Saab      * Handle requests for volumes that don't exist or are not online.
32336f71a953SPaul Saab      * A selection timeout is slightly better than an illegal request.
32346f71a953SPaul Saab      * Other errors might be better.
32353a31b7ebSMike Smith      */
32366f71a953SPaul Saab     if (sc->ciss_logical[bus][target].cl_status != CISS_LD_ONLINE) {
32370a65b79fSAlexander Motin 	csio->ccb_h.status |= CAM_SEL_TIMEOUT;
32383a31b7ebSMike Smith 	xpt_done((union ccb *)csio);
32393a31b7ebSMike Smith 	return(1);
32403a31b7ebSMike Smith     }
32413a31b7ebSMike Smith 
32423a31b7ebSMike Smith     /* if we have to fake Synchronise Cache */
32433a31b7ebSMike Smith     if (sc->ciss_flags & CISS_FLAG_FAKE_SYNCH) {
32443a31b7ebSMike Smith 	/*
32453a31b7ebSMike Smith 	 * If this is a Synchronise Cache command, typically issued when
32463a31b7ebSMike Smith 	 * a device is closed, flush the adapter and complete now.
32473a31b7ebSMike Smith 	 */
32483a31b7ebSMike Smith 	if (((csio->ccb_h.flags & CAM_CDB_POINTER) ?
32493a31b7ebSMike Smith 	     *(u_int8_t *)csio->cdb_io.cdb_ptr : csio->cdb_io.cdb_bytes[0]) == SYNCHRONIZE_CACHE) {
32503a31b7ebSMike Smith 	    ciss_flush_adapter(sc);
32510a65b79fSAlexander Motin 	    csio->ccb_h.status |= CAM_REQ_CMP;
32523a31b7ebSMike Smith 	    xpt_done((union ccb *)csio);
32533a31b7ebSMike Smith 	    return(1);
32543a31b7ebSMike Smith 	}
32553a31b7ebSMike Smith     }
32563a31b7ebSMike Smith 
3257a1abcc4fSSean Bruno     /*
3258a1abcc4fSSean Bruno      * A CISS target can only ever have one lun per target. REPORT_LUNS requires
3259a1abcc4fSSean Bruno      * at least one LUN field to be pre created for us, so snag it and fill in
3260a1abcc4fSSean Bruno      * the least significant byte indicating 1 LUN here.  Emulate the command
3261a1abcc4fSSean Bruno      * return to shut up warning on console of a CDB error.  swb
3262a1abcc4fSSean Bruno      */
3263a1abcc4fSSean Bruno     if (opcode == REPORT_LUNS && csio->dxfer_len > 0) {
3264a1abcc4fSSean Bruno        csio->data_ptr[3] = 8;
3265a1abcc4fSSean Bruno        csio->ccb_h.status |= CAM_REQ_CMP;
3266a1abcc4fSSean Bruno        xpt_done((union ccb *)csio);
3267a1abcc4fSSean Bruno        return(1);
3268a1abcc4fSSean Bruno     }
3269a1abcc4fSSean Bruno 
32703a31b7ebSMike Smith     return(0);
32713a31b7ebSMike Smith }
32723a31b7ebSMike Smith 
32733a31b7ebSMike Smith /************************************************************************
32743a31b7ebSMike Smith  * Check for possibly-completed commands.
32753a31b7ebSMike Smith  */
32763a31b7ebSMike Smith static void
32773a31b7ebSMike Smith ciss_cam_poll(struct cam_sim *sim)
32783a31b7ebSMike Smith {
327922657ce1SScott Long     cr_qhead_t qh;
32803a31b7ebSMike Smith     struct ciss_softc	*sc = cam_sim_softc(sim);
32813a31b7ebSMike Smith 
32823a31b7ebSMike Smith     debug_called(2);
32833a31b7ebSMike Smith 
328422657ce1SScott Long     STAILQ_INIT(&qh);
328522657ce1SScott Long     if (sc->ciss_perf)
328622657ce1SScott Long 	ciss_perf_done(sc, &qh);
328722657ce1SScott Long     else
328822657ce1SScott Long 	ciss_done(sc, &qh);
328922657ce1SScott Long     ciss_complete(sc, &qh);
32903a31b7ebSMike Smith }
32913a31b7ebSMike Smith 
32923a31b7ebSMike Smith /************************************************************************
32933a31b7ebSMike Smith  * Handle completion of a command - pass results back through the CCB
32943a31b7ebSMike Smith  */
32953a31b7ebSMike Smith static void
32963a31b7ebSMike Smith ciss_cam_complete(struct ciss_request *cr)
32973a31b7ebSMike Smith {
32983a31b7ebSMike Smith     struct ciss_softc		*sc;
32993a31b7ebSMike Smith     struct ciss_command		*cc;
33003a31b7ebSMike Smith     struct ciss_error_info	*ce;
33013a31b7ebSMike Smith     struct ccb_scsiio		*csio;
33023a31b7ebSMike Smith     int				scsi_status;
33033a31b7ebSMike Smith     int				command_status;
33043a31b7ebSMike Smith 
33053a31b7ebSMike Smith     debug_called(2);
33063a31b7ebSMike Smith 
33073a31b7ebSMike Smith     sc = cr->cr_sc;
33082fdaa90dSScott Long     cc = cr->cr_cc;
33093a31b7ebSMike Smith     ce = (struct ciss_error_info *)&(cc->sg[0]);
33103a31b7ebSMike Smith     csio = (struct ccb_scsiio *)cr->cr_private;
33113a31b7ebSMike Smith 
33123a31b7ebSMike Smith     /*
33133a31b7ebSMike Smith      * Extract status values from request.
33143a31b7ebSMike Smith      */
33153a31b7ebSMike Smith     ciss_report_request(cr, &command_status, &scsi_status);
3316e8144a13SAlexander Motin     switch(command_status) {
3317e8144a13SAlexander Motin     case CISS_CMD_STATUS_DATA_UNDERRUN:
3318e8144a13SAlexander Motin 	csio->resid = ce->residual_count;
3319e8144a13SAlexander Motin 	/* FALLTHROUGH */
3320e8144a13SAlexander Motin     case CISS_CMD_STATUS_SUCCESS:
33213a31b7ebSMike Smith 	csio->scsi_status = scsi_status;
33223a31b7ebSMike Smith 	debug(2, "SCSI_STATUS_OK");
33230a65b79fSAlexander Motin 	csio->ccb_h.status |= CAM_REQ_CMP;
33243a31b7ebSMike Smith 	break;
3325e8144a13SAlexander Motin     case CISS_CMD_STATUS_TARGET_STATUS:
3326e8144a13SAlexander Motin 	csio->scsi_status = scsi_status;
33273a31b7ebSMike Smith 	bzero(&csio->sense_data, SSD_FULL_SIZE);
33283a31b7ebSMike Smith 	bcopy(&ce->sense_info[0], &csio->sense_data, ce->sense_length);
33291cc052e8SKenneth D. Merry 	if (csio->sense_len > ce->sense_length)
33301cc052e8SKenneth D. Merry 		csio->sense_resid = csio->sense_len - ce->sense_length;
33311cc052e8SKenneth D. Merry 	else
33321cc052e8SKenneth D. Merry 		csio->sense_resid = 0;
33333a31b7ebSMike Smith 	csio->resid = ce->residual_count;
33340a65b79fSAlexander Motin 	csio->ccb_h.status |= CAM_SCSI_STATUS_ERROR | CAM_AUTOSNS_VALID;
33353a31b7ebSMike Smith 	break;
3336e8144a13SAlexander Motin     case CISS_CMD_STATUS_DATA_OVERRUN:
3337e8144a13SAlexander Motin 	csio->ccb_h.status |= CAM_DATA_RUN_ERR;
33383a31b7ebSMike Smith 	break;
33393a31b7ebSMike Smith     default:
33400a65b79fSAlexander Motin 	csio->ccb_h.status |= CAM_REQ_CMP_ERR;
33413a31b7ebSMike Smith 	break;
33423a31b7ebSMike Smith     }
33433a31b7ebSMike Smith 
33443a31b7ebSMike Smith     /* handle post-command fixup */
33453a31b7ebSMike Smith     ciss_cam_complete_fixup(sc, csio);
33463a31b7ebSMike Smith 
33473a31b7ebSMike Smith     ciss_release_request(cr);
334895dab4f2SAlexander Motin     if (sc->ciss_flags & CISS_FLAG_BUSY) {
334995dab4f2SAlexander Motin 	sc->ciss_flags &= ~CISS_FLAG_BUSY;
335095dab4f2SAlexander Motin 	if (csio->ccb_h.status & CAM_RELEASE_SIMQ)
335195dab4f2SAlexander Motin 	    xpt_release_simq(xpt_path_sim(csio->ccb_h.path), 0);
335295dab4f2SAlexander Motin 	else
335395dab4f2SAlexander Motin 	    csio->ccb_h.status |= CAM_RELEASE_SIMQ;
335495dab4f2SAlexander Motin     }
335522657ce1SScott Long     xpt_done((union ccb *)csio);
33563a31b7ebSMike Smith }
33573a31b7ebSMike Smith 
33583a31b7ebSMike Smith /********************************************************************************
33593a31b7ebSMike Smith  * Fix up the result of some commands here.
33603a31b7ebSMike Smith  */
33613a31b7ebSMike Smith static void
33623a31b7ebSMike Smith ciss_cam_complete_fixup(struct ciss_softc *sc, struct ccb_scsiio *csio)
33633a31b7ebSMike Smith {
33643a31b7ebSMike Smith     struct scsi_inquiry_data	*inq;
33653a31b7ebSMike Smith     struct ciss_ldrive		*cl;
336657ae362cSAlexander Motin     uint8_t			*cdb;
3367c6131460SPaul Saab     int				bus, target;
33683a31b7ebSMike Smith 
336957ae362cSAlexander Motin     cdb = (csio->ccb_h.flags & CAM_CDB_POINTER) ?
337057ae362cSAlexander Motin 	 (uint8_t *)csio->cdb_io.cdb_ptr : csio->cdb_io.cdb_bytes;
337157ae362cSAlexander Motin     if (cdb[0] == INQUIRY &&
337257ae362cSAlexander Motin 	(cdb[1] & SI_EVPD) == 0 &&
337357ae362cSAlexander Motin 	(csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN &&
337457ae362cSAlexander Motin 	csio->dxfer_len >= SHORT_INQUIRY_LENGTH) {
33753a31b7ebSMike Smith 	inq = (struct scsi_inquiry_data *)csio->data_ptr;
33763a31b7ebSMike Smith 	target = csio->ccb_h.target_id;
3377c6131460SPaul Saab 	bus = cam_sim_bus(xpt_path_sim(csio->ccb_h.path));
33781fe6c4eeSScott Long 
33791fe6c4eeSScott Long 	/*
33800fb31ed0SSean Bruno 	 * If the controller is in JBOD mode, there are no logical volumes.
33810fb31ed0SSean Bruno 	 * Let the disks be probed and dealt with via CAM.  Else, mask off
33820fb31ed0SSean Bruno 	 * the physical disks and setup the parts of the inq structure for
33830fb31ed0SSean Bruno 	 * the logical volume.  swb
33841fe6c4eeSScott Long 	 */
33850fb31ed0SSean Bruno 	if( !(sc->ciss_id->PowerUPNvramFlags & PWR_UP_FLAG_JBOD_ENABLED)){
33861fe6c4eeSScott Long 		if (CISS_IS_PHYSICAL(bus)) {
33871fe6c4eeSScott Long 	    		if (SID_TYPE(inq) == T_DIRECT)
33881fe6c4eeSScott Long 				inq->device = (inq->device & 0xe0) | T_NODEVICE;
33891fe6c4eeSScott Long 	    		return;
33901fe6c4eeSScott Long 		}
3391c6131460SPaul Saab 		cl = &sc->ciss_logical[bus][target];
33923a31b7ebSMike Smith 
33931e8b29a4SSean Bruno 		padstr(inq->vendor, "HP",
3394a9112e5dSSean Bruno 	       		SID_VENDOR_SIZE);
3395a9112e5dSSean Bruno 		padstr(inq->product,
3396a9112e5dSSean Bruno 	       		ciss_name_ldrive_org(cl->cl_ldrive->fault_tolerance),
3397a9112e5dSSean Bruno 	       		SID_PRODUCT_SIZE);
3398a9112e5dSSean Bruno 		padstr(inq->revision,
3399a9112e5dSSean Bruno 	       		ciss_name_ldrive_status(cl->cl_lstatus->status),
3400a9112e5dSSean Bruno 	       		SID_REVISION_SIZE);
34013a31b7ebSMike Smith 	}
34023a31b7ebSMike Smith     }
34030fb31ed0SSean Bruno }
34043a31b7ebSMike Smith 
34053a31b7ebSMike Smith /********************************************************************************
34063a31b7ebSMike Smith  * Name the device at (target)
34073a31b7ebSMike Smith  *
34083a31b7ebSMike Smith  * XXX is this strictly correct?
34093a31b7ebSMike Smith  */
341037c84183SPoul-Henning Kamp static int
3411c6131460SPaul Saab ciss_name_device(struct ciss_softc *sc, int bus, int target)
34123a31b7ebSMike Smith {
34133a31b7ebSMike Smith     struct cam_periph	*periph;
3414739a9399SSean Bruno     struct cam_path	*path;
3415739a9399SSean Bruno     int			status;
34163a31b7ebSMike Smith 
3417d49f1379SPaul Saab     if (CISS_IS_PHYSICAL(bus))
34181fe6c4eeSScott Long 	return (0);
3419739a9399SSean Bruno 
3420739a9399SSean Bruno     status = xpt_create_path(&path, NULL, cam_sim_path(sc->ciss_cam_sim[bus]),
3421739a9399SSean Bruno 			     target, 0);
3422739a9399SSean Bruno 
3423739a9399SSean Bruno     if (status == CAM_REQ_CMP) {
3424739a9399SSean Bruno 	xpt_path_lock(path);
3425739a9399SSean Bruno 	periph = cam_periph_find(path, NULL);
342697ed09b5SSean Bruno 	xpt_path_unlock(path);
342797ed09b5SSean Bruno 	xpt_free_path(path);
342897ed09b5SSean Bruno 	if (periph != NULL) {
34291fe6c4eeSScott Long 		sprintf(sc->ciss_logical[bus][target].cl_name, "%s%d",
34301fe6c4eeSScott Long 			periph->periph_name, periph->unit_number);
34313a31b7ebSMike Smith 		return(0);
34323a31b7ebSMike Smith 	}
343397ed09b5SSean Bruno     }
3434c6131460SPaul Saab     sc->ciss_logical[bus][target].cl_name[0] = 0;
34353a31b7ebSMike Smith     return(ENOENT);
34363a31b7ebSMike Smith }
34373a31b7ebSMike Smith 
34383a31b7ebSMike Smith /************************************************************************
34393a31b7ebSMike Smith  * Periodic status monitoring.
34403a31b7ebSMike Smith  */
34413a31b7ebSMike Smith static void
34423a31b7ebSMike Smith ciss_periodic(void *arg)
34433a31b7ebSMike Smith {
34443a31b7ebSMike Smith     struct ciss_softc	*sc;
3445e08d902aSMitsuru IWASAKI     struct ciss_request	*cr = NULL;
3446e08d902aSMitsuru IWASAKI     struct ciss_command	*cc = NULL;
3447e08d902aSMitsuru IWASAKI     int			error = 0;
34483a31b7ebSMike Smith 
34493a31b7ebSMike Smith     debug_called(1);
34503a31b7ebSMike Smith 
34513a31b7ebSMike Smith     sc = (struct ciss_softc *)arg;
34523a31b7ebSMike Smith 
34533a31b7ebSMike Smith     /*
34543a31b7ebSMike Smith      * Check the adapter heartbeat.
34553a31b7ebSMike Smith      */
34563a31b7ebSMike Smith     if (sc->ciss_cfg->heartbeat == sc->ciss_heartbeat) {
34573a31b7ebSMike Smith 	sc->ciss_heart_attack++;
34583a31b7ebSMike Smith 	debug(0, "adapter heart attack in progress 0x%x/%d",
34593a31b7ebSMike Smith 	      sc->ciss_heartbeat, sc->ciss_heart_attack);
34603a31b7ebSMike Smith 	if (sc->ciss_heart_attack == 3) {
34613a31b7ebSMike Smith 	    ciss_printf(sc, "ADAPTER HEARTBEAT FAILED\n");
3462e08d902aSMitsuru IWASAKI 	    ciss_disable_adapter(sc);
3463e08d902aSMitsuru IWASAKI 	    return;
34643a31b7ebSMike Smith 	}
34653a31b7ebSMike Smith     } else {
34663a31b7ebSMike Smith 	sc->ciss_heartbeat = sc->ciss_cfg->heartbeat;
34673a31b7ebSMike Smith 	sc->ciss_heart_attack = 0;
34683a31b7ebSMike Smith 	debug(3, "new heartbeat 0x%x", sc->ciss_heartbeat);
34693a31b7ebSMike Smith     }
34703a31b7ebSMike Smith 
34713a31b7ebSMike Smith     /*
3472e08d902aSMitsuru IWASAKI      * Send the NOP message and wait for a response.
3473e08d902aSMitsuru IWASAKI      */
34745a3c4d69SMitsuru IWASAKI     if (ciss_nop_message_heartbeat != 0 && (error = ciss_get_request(sc, &cr)) == 0) {
34752fdaa90dSScott Long 	cc = cr->cr_cc;
347654d02e0aSMitsuru IWASAKI 	cr->cr_complete = ciss_nop_complete;
3477e08d902aSMitsuru IWASAKI 	cc->cdb.cdb_length = 1;
3478e08d902aSMitsuru IWASAKI 	cc->cdb.type = CISS_CDB_TYPE_MESSAGE;
3479e08d902aSMitsuru IWASAKI 	cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;
3480e08d902aSMitsuru IWASAKI 	cc->cdb.direction = CISS_CDB_DIRECTION_WRITE;
3481e08d902aSMitsuru IWASAKI 	cc->cdb.timeout = 0;
3482e08d902aSMitsuru IWASAKI 	cc->cdb.cdb[0] = CISS_OPCODE_MESSAGE_NOP;
3483e08d902aSMitsuru IWASAKI 
348454d02e0aSMitsuru IWASAKI 	if ((error = ciss_start(cr)) != 0) {
3485e08d902aSMitsuru IWASAKI 	    ciss_printf(sc, "SENDING NOP MESSAGE FAILED\n");
3486e08d902aSMitsuru IWASAKI 	}
3487e08d902aSMitsuru IWASAKI     }
3488e08d902aSMitsuru IWASAKI 
3489e08d902aSMitsuru IWASAKI     /*
34903a31b7ebSMike Smith      * If the notify event request has died for some reason, or has
34913a31b7ebSMike Smith      * not started yet, restart it.
34923a31b7ebSMike Smith      */
34933a31b7ebSMike Smith     if (!(sc->ciss_flags & CISS_FLAG_NOTIFY_OK)) {
34943a31b7ebSMike Smith 	debug(0, "(re)starting Event Notify chain");
34953a31b7ebSMike Smith 	ciss_notify_event(sc);
34963a31b7ebSMike Smith     }
34973a31b7ebSMike Smith 
34983a31b7ebSMike Smith     /*
34993a31b7ebSMike Smith      * Reschedule.
35003a31b7ebSMike Smith      */
3501975b7318SScott Long     callout_reset(&sc->ciss_periodic, CISS_HEARTBEAT_RATE * hz, ciss_periodic, sc);
35023a31b7ebSMike Smith }
35033a31b7ebSMike Smith 
350454d02e0aSMitsuru IWASAKI static void
350554d02e0aSMitsuru IWASAKI ciss_nop_complete(struct ciss_request *cr)
350654d02e0aSMitsuru IWASAKI {
350754d02e0aSMitsuru IWASAKI     struct ciss_softc		*sc;
35080aeee4bdSMitsuru IWASAKI     static int			first_time = 1;
350954d02e0aSMitsuru IWASAKI 
351054d02e0aSMitsuru IWASAKI     sc = cr->cr_sc;
351154d02e0aSMitsuru IWASAKI     if (ciss_report_request(cr, NULL, NULL) != 0) {
35120aeee4bdSMitsuru IWASAKI 	if (first_time == 1) {
35130aeee4bdSMitsuru IWASAKI 	    first_time = 0;
35140aeee4bdSMitsuru IWASAKI 	    ciss_printf(sc, "SENDING NOP MESSAGE FAILED (not logging anymore)\n");
35150aeee4bdSMitsuru IWASAKI 	}
351654d02e0aSMitsuru IWASAKI     }
351754d02e0aSMitsuru IWASAKI 
351854d02e0aSMitsuru IWASAKI     ciss_release_request(cr);
351954d02e0aSMitsuru IWASAKI }
352054d02e0aSMitsuru IWASAKI 
35213a31b7ebSMike Smith /************************************************************************
3522e08d902aSMitsuru IWASAKI  * Disable the adapter.
3523e08d902aSMitsuru IWASAKI  *
3524e08d902aSMitsuru IWASAKI  * The all requests in completed queue is failed with hardware error.
3525e08d902aSMitsuru IWASAKI  * This will cause failover in a multipath configuration.
3526e08d902aSMitsuru IWASAKI  */
3527e08d902aSMitsuru IWASAKI static void
3528e08d902aSMitsuru IWASAKI ciss_disable_adapter(struct ciss_softc *sc)
3529e08d902aSMitsuru IWASAKI {
353022657ce1SScott Long     cr_qhead_t			qh;
3531e08d902aSMitsuru IWASAKI     struct ciss_request		*cr;
3532e08d902aSMitsuru IWASAKI     struct ciss_command		*cc;
3533e08d902aSMitsuru IWASAKI     struct ciss_error_info	*ce;
353422657ce1SScott Long     int				i;
3535e08d902aSMitsuru IWASAKI 
3536e08d902aSMitsuru IWASAKI     CISS_TL_SIMPLE_DISABLE_INTERRUPTS(sc);
3537e08d902aSMitsuru IWASAKI     pci_disable_busmaster(sc->ciss_dev);
3538e08d902aSMitsuru IWASAKI     sc->ciss_flags &= ~CISS_FLAG_RUNNING;
3539e08d902aSMitsuru IWASAKI 
3540d26ae2c1SAlexander Motin     STAILQ_INIT(&qh);
354122657ce1SScott Long     for (i = 1; i < sc->ciss_max_requests; i++) {
354222657ce1SScott Long 	cr = &sc->ciss_request[i];
354322657ce1SScott Long 	if ((cr->cr_flags & CISS_REQ_BUSY) == 0)
354422657ce1SScott Long 	    continue;
3545e08d902aSMitsuru IWASAKI 
35462fdaa90dSScott Long 	cc = cr->cr_cc;
3547e08d902aSMitsuru IWASAKI 	ce = (struct ciss_error_info *)&(cc->sg[0]);
3548e08d902aSMitsuru IWASAKI 	ce->command_status = CISS_CMD_STATUS_HARDWARE_ERROR;
354922657ce1SScott Long 	ciss_enqueue_complete(cr, &qh);
3550e08d902aSMitsuru IWASAKI     }
3551e08d902aSMitsuru IWASAKI 
3552e08d902aSMitsuru IWASAKI     for (;;) {
355322657ce1SScott Long 	if ((cr = ciss_dequeue_complete(sc, &qh)) == NULL)
3554e08d902aSMitsuru IWASAKI 	    break;
3555e08d902aSMitsuru IWASAKI 
3556e08d902aSMitsuru IWASAKI 	/*
3557e08d902aSMitsuru IWASAKI 	 * If the request has a callback, invoke it.
3558e08d902aSMitsuru IWASAKI 	 */
3559e08d902aSMitsuru IWASAKI 	if (cr->cr_complete != NULL) {
3560e08d902aSMitsuru IWASAKI 	    cr->cr_complete(cr);
3561e08d902aSMitsuru IWASAKI 	    continue;
3562e08d902aSMitsuru IWASAKI 	}
3563e08d902aSMitsuru IWASAKI 
3564e08d902aSMitsuru IWASAKI 	/*
3565e08d902aSMitsuru IWASAKI 	 * If someone is sleeping on this request, wake them up.
3566e08d902aSMitsuru IWASAKI 	 */
3567e08d902aSMitsuru IWASAKI 	if (cr->cr_flags & CISS_REQ_SLEEP) {
3568e08d902aSMitsuru IWASAKI 	    cr->cr_flags &= ~CISS_REQ_SLEEP;
3569e08d902aSMitsuru IWASAKI 	    wakeup(cr);
3570e08d902aSMitsuru IWASAKI 	    continue;
3571e08d902aSMitsuru IWASAKI 	}
3572e08d902aSMitsuru IWASAKI     }
3573e08d902aSMitsuru IWASAKI }
3574e08d902aSMitsuru IWASAKI 
3575e08d902aSMitsuru IWASAKI /************************************************************************
35763a31b7ebSMike Smith  * Request a notification response from the adapter.
35773a31b7ebSMike Smith  *
35783a31b7ebSMike Smith  * If (cr) is NULL, this is the first request of the adapter, so
35793a31b7ebSMike Smith  * reset the adapter's message pointer and start with the oldest
35803a31b7ebSMike Smith  * message available.
35813a31b7ebSMike Smith  */
35823a31b7ebSMike Smith static void
35833a31b7ebSMike Smith ciss_notify_event(struct ciss_softc *sc)
35843a31b7ebSMike Smith {
35853a31b7ebSMike Smith     struct ciss_request		*cr;
35863a31b7ebSMike Smith     struct ciss_command		*cc;
35873a31b7ebSMike Smith     struct ciss_notify_cdb	*cnc;
35883a31b7ebSMike Smith     int				error;
35893a31b7ebSMike Smith 
35903a31b7ebSMike Smith     debug_called(1);
35913a31b7ebSMike Smith 
35923a31b7ebSMike Smith     cr = sc->ciss_periodic_notify;
35933a31b7ebSMike Smith 
35943a31b7ebSMike Smith     /* get a request if we don't already have one */
35953a31b7ebSMike Smith     if (cr == NULL) {
35963a31b7ebSMike Smith 	if ((error = ciss_get_request(sc, &cr)) != 0) {
35973a31b7ebSMike Smith 	    debug(0, "can't get notify event request");
35983a31b7ebSMike Smith 	    goto out;
35993a31b7ebSMike Smith 	}
36003a31b7ebSMike Smith 	sc->ciss_periodic_notify = cr;
36013a31b7ebSMike Smith 	cr->cr_complete = ciss_notify_complete;
36023a31b7ebSMike Smith 	debug(1, "acquired request %d", cr->cr_tag);
36033a31b7ebSMike Smith     }
36043a31b7ebSMike Smith 
36053a31b7ebSMike Smith     /*
36063a31b7ebSMike Smith      * Get a databuffer if we don't already have one, note that the
36073a31b7ebSMike Smith      * adapter command wants a larger buffer than the actual
36083a31b7ebSMike Smith      * structure.
36093a31b7ebSMike Smith      */
36103a31b7ebSMike Smith     if (cr->cr_data == NULL) {
36113a31b7ebSMike Smith 	if ((cr->cr_data = malloc(CISS_NOTIFY_DATA_SIZE, CISS_MALLOC_CLASS, M_NOWAIT)) == NULL) {
36123a31b7ebSMike Smith 	    debug(0, "can't get notify event request buffer");
36133a31b7ebSMike Smith 	    error = ENOMEM;
36143a31b7ebSMike Smith 	    goto out;
36153a31b7ebSMike Smith 	}
36163a31b7ebSMike Smith 	cr->cr_length = CISS_NOTIFY_DATA_SIZE;
36173a31b7ebSMike Smith     }
36183a31b7ebSMike Smith 
36193a31b7ebSMike Smith     /* re-setup the request's command (since we never release it) XXX overkill*/
36203a31b7ebSMike Smith     ciss_preen_command(cr);
36213a31b7ebSMike Smith 
36223a31b7ebSMike Smith     /* (re)build the notify event command */
36232fdaa90dSScott Long     cc = cr->cr_cc;
36243a31b7ebSMike Smith     cc->header.address.physical.mode = CISS_HDR_ADDRESS_MODE_PERIPHERAL;
36253a31b7ebSMike Smith     cc->header.address.physical.bus = 0;
36263a31b7ebSMike Smith     cc->header.address.physical.target = 0;
36273a31b7ebSMike Smith 
36283a31b7ebSMike Smith     cc->cdb.cdb_length = sizeof(*cnc);
36293a31b7ebSMike Smith     cc->cdb.type = CISS_CDB_TYPE_COMMAND;
36303a31b7ebSMike Smith     cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;
36313a31b7ebSMike Smith     cc->cdb.direction = CISS_CDB_DIRECTION_READ;
36323a31b7ebSMike Smith     cc->cdb.timeout = 0;	/* no timeout, we hope */
36333a31b7ebSMike Smith 
36343a31b7ebSMike Smith     cnc = (struct ciss_notify_cdb *)&(cc->cdb.cdb[0]);
36353a31b7ebSMike Smith     bzero(cr->cr_data, CISS_NOTIFY_DATA_SIZE);
36363a31b7ebSMike Smith     cnc->opcode = CISS_OPCODE_READ;
36373a31b7ebSMike Smith     cnc->command = CISS_COMMAND_NOTIFY_ON_EVENT;
36383a31b7ebSMike Smith     cnc->timeout = 0;		/* no timeout, we hope */
36393a31b7ebSMike Smith     cnc->synchronous = 0;
36403a31b7ebSMike Smith     cnc->ordered = 0;
36413a31b7ebSMike Smith     cnc->seek_to_oldest = 0;
36422e80ca8aSPaul Saab     if ((sc->ciss_flags & CISS_FLAG_RUNNING) == 0)
36432e80ca8aSPaul Saab 	cnc->new_only = 1;
36442e80ca8aSPaul Saab     else
36453a31b7ebSMike Smith 	cnc->new_only = 0;
36463a31b7ebSMike Smith     cnc->length = htonl(CISS_NOTIFY_DATA_SIZE);
36473a31b7ebSMike Smith 
36483a31b7ebSMike Smith     /* submit the request */
36493a31b7ebSMike Smith     error = ciss_start(cr);
36503a31b7ebSMike Smith 
36513a31b7ebSMike Smith  out:
36523a31b7ebSMike Smith     if (error) {
36533a31b7ebSMike Smith 	if (cr != NULL) {
36543a31b7ebSMike Smith 	    if (cr->cr_data != NULL)
36553a31b7ebSMike Smith 		free(cr->cr_data, CISS_MALLOC_CLASS);
36563a31b7ebSMike Smith 	    ciss_release_request(cr);
36573a31b7ebSMike Smith 	}
36583a31b7ebSMike Smith 	sc->ciss_periodic_notify = NULL;
36593a31b7ebSMike Smith 	debug(0, "can't submit notify event request");
36603a31b7ebSMike Smith 	sc->ciss_flags &= ~CISS_FLAG_NOTIFY_OK;
36613a31b7ebSMike Smith     } else {
36623a31b7ebSMike Smith 	debug(1, "notify event submitted");
36633a31b7ebSMike Smith 	sc->ciss_flags |= CISS_FLAG_NOTIFY_OK;
36643a31b7ebSMike Smith     }
36653a31b7ebSMike Smith }
36663a31b7ebSMike Smith 
36673a31b7ebSMike Smith static void
36683a31b7ebSMike Smith ciss_notify_complete(struct ciss_request *cr)
36693a31b7ebSMike Smith {
36703a31b7ebSMike Smith     struct ciss_command	*cc;
36713a31b7ebSMike Smith     struct ciss_notify	*cn;
36723a31b7ebSMike Smith     struct ciss_softc	*sc;
36733a31b7ebSMike Smith     int			scsi_status;
36743a31b7ebSMike Smith     int			command_status;
36753a31b7ebSMike Smith     debug_called(1);
36763a31b7ebSMike Smith 
36772fdaa90dSScott Long     cc = cr->cr_cc;
36783a31b7ebSMike Smith     cn = (struct ciss_notify *)cr->cr_data;
36793a31b7ebSMike Smith     sc = cr->cr_sc;
36803a31b7ebSMike Smith 
36813a31b7ebSMike Smith     /*
36823a31b7ebSMike Smith      * Report request results, decode status.
36833a31b7ebSMike Smith      */
36843a31b7ebSMike Smith     ciss_report_request(cr, &command_status, &scsi_status);
36853a31b7ebSMike Smith 
36863a31b7ebSMike Smith     /*
36873a31b7ebSMike Smith      * Abort the chain on a fatal error.
36883a31b7ebSMike Smith      *
36893a31b7ebSMike Smith      * XXX which of these are actually errors?
36903a31b7ebSMike Smith      */
36913a31b7ebSMike Smith     if ((command_status != CISS_CMD_STATUS_SUCCESS) &&
36923a31b7ebSMike Smith 	(command_status != CISS_CMD_STATUS_TARGET_STATUS) &&
36933a31b7ebSMike Smith 	(command_status != CISS_CMD_STATUS_TIMEOUT)) {	/* XXX timeout? */
36943a31b7ebSMike Smith 	ciss_printf(sc, "fatal error in Notify Event request (%s)\n",
36953a31b7ebSMike Smith 		    ciss_name_command_status(command_status));
36963a31b7ebSMike Smith 	ciss_release_request(cr);
36973a31b7ebSMike Smith 	sc->ciss_flags &= ~CISS_FLAG_NOTIFY_OK;
36983a31b7ebSMike Smith 	return;
36993a31b7ebSMike Smith     }
37003a31b7ebSMike Smith 
37013a31b7ebSMike Smith     /*
37023a31b7ebSMike Smith      * If the adapter gave us a text message, print it.
37033a31b7ebSMike Smith      */
37043a31b7ebSMike Smith     if (cn->message[0] != 0)
37053a31b7ebSMike Smith 	ciss_printf(sc, "*** %.80s\n", cn->message);
37063a31b7ebSMike Smith 
37073a31b7ebSMike Smith     debug(0, "notify event class %d subclass %d detail %d",
37083a31b7ebSMike Smith 		cn->class, cn->subclass, cn->detail);
37093a31b7ebSMike Smith 
37103a31b7ebSMike Smith     /*
37113a31b7ebSMike Smith      * If the response indicates that the notifier has been aborted,
37123a31b7ebSMike Smith      * release the notifier command.
37133a31b7ebSMike Smith      */
37143a31b7ebSMike Smith     if ((cn->class == CISS_NOTIFY_NOTIFIER) &&
37153a31b7ebSMike Smith 	(cn->subclass == CISS_NOTIFY_NOTIFIER_STATUS) &&
37163a31b7ebSMike Smith 	(cn->detail == 1)) {
37173a31b7ebSMike Smith 	debug(0, "notifier exiting");
37183a31b7ebSMike Smith 	sc->ciss_flags &= ~CISS_FLAG_NOTIFY_OK;
37193a31b7ebSMike Smith 	ciss_release_request(cr);
37203a31b7ebSMike Smith 	sc->ciss_periodic_notify = NULL;
37213a31b7ebSMike Smith 	wakeup(&sc->ciss_periodic_notify);
3722c6131460SPaul Saab     } else {
3723c6131460SPaul Saab 	/* Handle notify events in a kernel thread */
3724c6131460SPaul Saab 	ciss_enqueue_notify(cr);
3725c6131460SPaul Saab 	sc->ciss_periodic_notify = NULL;
3726c6131460SPaul Saab 	wakeup(&sc->ciss_periodic_notify);
3727c6131460SPaul Saab 	wakeup(&sc->ciss_notify);
37283a31b7ebSMike Smith     }
37293a31b7ebSMike Smith     /*
37303a31b7ebSMike Smith      * Send a new notify event command, if we're not aborting.
37313a31b7ebSMike Smith      */
37323a31b7ebSMike Smith     if (!(sc->ciss_flags & CISS_FLAG_ABORTING)) {
37333a31b7ebSMike Smith 	ciss_notify_event(sc);
37343a31b7ebSMike Smith     }
37353a31b7ebSMike Smith }
37363a31b7ebSMike Smith 
37373a31b7ebSMike Smith /************************************************************************
37383a31b7ebSMike Smith  * Abort the Notify Event chain.
37393a31b7ebSMike Smith  *
37403a31b7ebSMike Smith  * Note that we can't just abort the command in progress; we have to
37413a31b7ebSMike Smith  * explicitly issue an Abort Notify Event command in order for the
37423a31b7ebSMike Smith  * adapter to clean up correctly.
37433a31b7ebSMike Smith  *
37443a31b7ebSMike Smith  * If we are called with CISS_FLAG_ABORTING set in the adapter softc,
37453a31b7ebSMike Smith  * the chain will not restart itself.
37463a31b7ebSMike Smith  */
37473a31b7ebSMike Smith static int
37483a31b7ebSMike Smith ciss_notify_abort(struct ciss_softc *sc)
37493a31b7ebSMike Smith {
37503a31b7ebSMike Smith     struct ciss_request		*cr;
37513a31b7ebSMike Smith     struct ciss_command		*cc;
37523a31b7ebSMike Smith     struct ciss_notify_cdb	*cnc;
375322657ce1SScott Long     int				error, command_status, scsi_status;
37543a31b7ebSMike Smith 
37553a31b7ebSMike Smith     debug_called(1);
37563a31b7ebSMike Smith 
37573a31b7ebSMike Smith     cr = NULL;
37583a31b7ebSMike Smith     error = 0;
37593a31b7ebSMike Smith 
37603a31b7ebSMike Smith     /* verify that there's an outstanding command */
37613a31b7ebSMike Smith     if (!(sc->ciss_flags & CISS_FLAG_NOTIFY_OK))
37623a31b7ebSMike Smith 	goto out;
37633a31b7ebSMike Smith 
37643a31b7ebSMike Smith     /* get a command to issue the abort with */
37653a31b7ebSMike Smith     if ((error = ciss_get_request(sc, &cr)))
37663a31b7ebSMike Smith 	goto out;
37673a31b7ebSMike Smith 
37683a31b7ebSMike Smith     /* get a buffer for the result */
37693a31b7ebSMike Smith     if ((cr->cr_data = malloc(CISS_NOTIFY_DATA_SIZE, CISS_MALLOC_CLASS, M_NOWAIT)) == NULL) {
37703a31b7ebSMike Smith 	debug(0, "can't get notify event request buffer");
37713a31b7ebSMike Smith 	error = ENOMEM;
37723a31b7ebSMike Smith 	goto out;
37733a31b7ebSMike Smith     }
37743a31b7ebSMike Smith     cr->cr_length = CISS_NOTIFY_DATA_SIZE;
37753a31b7ebSMike Smith 
37763a31b7ebSMike Smith     /* build the CDB */
37772fdaa90dSScott Long     cc = cr->cr_cc;
37783a31b7ebSMike Smith     cc->header.address.physical.mode = CISS_HDR_ADDRESS_MODE_PERIPHERAL;
37793a31b7ebSMike Smith     cc->header.address.physical.bus = 0;
37803a31b7ebSMike Smith     cc->header.address.physical.target = 0;
37813a31b7ebSMike Smith     cc->cdb.cdb_length = sizeof(*cnc);
37823a31b7ebSMike Smith     cc->cdb.type = CISS_CDB_TYPE_COMMAND;
37833a31b7ebSMike Smith     cc->cdb.attribute = CISS_CDB_ATTRIBUTE_SIMPLE;
37843a31b7ebSMike Smith     cc->cdb.direction = CISS_CDB_DIRECTION_READ;
37853a31b7ebSMike Smith     cc->cdb.timeout = 0;	/* no timeout, we hope */
37863a31b7ebSMike Smith 
37873a31b7ebSMike Smith     cnc = (struct ciss_notify_cdb *)&(cc->cdb.cdb[0]);
37883a31b7ebSMike Smith     bzero(cnc, sizeof(*cnc));
37893a31b7ebSMike Smith     cnc->opcode = CISS_OPCODE_WRITE;
37903a31b7ebSMike Smith     cnc->command = CISS_COMMAND_ABORT_NOTIFY;
37913a31b7ebSMike Smith     cnc->length = htonl(CISS_NOTIFY_DATA_SIZE);
37922e3d6d0fSWarner Losh #if 0
37933a31b7ebSMike Smith     ciss_print_request(cr);
37942e3d6d0fSWarner Losh #endif
37953a31b7ebSMike Smith 
37963a31b7ebSMike Smith     /*
37973a31b7ebSMike Smith      * Submit the request and wait for it to complete.
37983a31b7ebSMike Smith      */
37993a31b7ebSMike Smith     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
38003a31b7ebSMike Smith 	ciss_printf(sc, "Abort Notify Event command failed (%d)\n", error);
38013a31b7ebSMike Smith 	goto out;
38023a31b7ebSMike Smith     }
38033a31b7ebSMike Smith 
38043a31b7ebSMike Smith     /*
38053a31b7ebSMike Smith      * Check response.
38063a31b7ebSMike Smith      */
38073a31b7ebSMike Smith     ciss_report_request(cr, &command_status, &scsi_status);
38083a31b7ebSMike Smith     switch(command_status) {
38093a31b7ebSMike Smith     case CISS_CMD_STATUS_SUCCESS:
38103a31b7ebSMike Smith 	break;
38113a31b7ebSMike Smith     case CISS_CMD_STATUS_INVALID_COMMAND:
38123a31b7ebSMike Smith 	/*
38133a31b7ebSMike Smith 	 * Some older adapters don't support the CISS version of this
38143a31b7ebSMike Smith 	 * command.  Fall back to using the BMIC version.
38153a31b7ebSMike Smith 	 */
38163a31b7ebSMike Smith 	error = ciss_notify_abort_bmic(sc);
38173a31b7ebSMike Smith 	if (error != 0)
38183a31b7ebSMike Smith 	    goto out;
38193a31b7ebSMike Smith 	break;
38203a31b7ebSMike Smith 
38213a31b7ebSMike Smith     case CISS_CMD_STATUS_TARGET_STATUS:
38223a31b7ebSMike Smith 	/*
38233a31b7ebSMike Smith 	 * This can happen if the adapter thinks there wasn't an outstanding
38243a31b7ebSMike Smith 	 * Notify Event command but we did.  We clean up here.
38253a31b7ebSMike Smith 	 */
38263a31b7ebSMike Smith 	if (scsi_status == CISS_SCSI_STATUS_CHECK_CONDITION) {
38273a31b7ebSMike Smith 	    if (sc->ciss_periodic_notify != NULL)
38283a31b7ebSMike Smith 		ciss_release_request(sc->ciss_periodic_notify);
38293a31b7ebSMike Smith 	    error = 0;
38303a31b7ebSMike Smith 	    goto out;
38313a31b7ebSMike Smith 	}
38323a31b7ebSMike Smith 	/* FALLTHROUGH */
38333a31b7ebSMike Smith 
38343a31b7ebSMike Smith     default:
38353a31b7ebSMike Smith 	ciss_printf(sc, "Abort Notify Event command failed (%s)\n",
38363a31b7ebSMike Smith 		    ciss_name_command_status(command_status));
38373a31b7ebSMike Smith 	error = EIO;
38383a31b7ebSMike Smith 	goto out;
38393a31b7ebSMike Smith     }
38403a31b7ebSMike Smith 
38413a31b7ebSMike Smith     /*
38423a31b7ebSMike Smith      * Sleep waiting for the notifier command to complete.  Note
38433a31b7ebSMike Smith      * that if it doesn't, we may end up in a bad situation, since
38443a31b7ebSMike Smith      * the adapter may deliver it later.  Also note that the adapter
38453a31b7ebSMike Smith      * requires the Notify Event command to be cancelled in order to
38463a31b7ebSMike Smith      * maintain internal bookkeeping.
38473a31b7ebSMike Smith      */
38483a31b7ebSMike Smith     while (sc->ciss_periodic_notify != NULL) {
3849975b7318SScott Long 	error = msleep(&sc->ciss_periodic_notify, &sc->ciss_mtx, PRIBIO, "cissNEA", hz * 5);
38503a31b7ebSMike Smith 	if (error == EWOULDBLOCK) {
38513a31b7ebSMike Smith 	    ciss_printf(sc, "Notify Event command failed to abort, adapter may wedge.\n");
38523a31b7ebSMike Smith 	    break;
38533a31b7ebSMike Smith 	}
38543a31b7ebSMike Smith     }
38553a31b7ebSMike Smith 
38563a31b7ebSMike Smith  out:
38573a31b7ebSMike Smith     /* release the cancel request */
38583a31b7ebSMike Smith     if (cr != NULL) {
38593a31b7ebSMike Smith 	if (cr->cr_data != NULL)
38603a31b7ebSMike Smith 	    free(cr->cr_data, CISS_MALLOC_CLASS);
38613a31b7ebSMike Smith 	ciss_release_request(cr);
38623a31b7ebSMike Smith     }
38633a31b7ebSMike Smith     if (error == 0)
38643a31b7ebSMike Smith 	sc->ciss_flags &= ~CISS_FLAG_NOTIFY_OK;
38653a31b7ebSMike Smith     return(error);
38663a31b7ebSMike Smith }
38673a31b7ebSMike Smith 
38683a31b7ebSMike Smith /************************************************************************
38693a31b7ebSMike Smith  * Abort the Notify Event chain using a BMIC command.
38703a31b7ebSMike Smith  */
38713a31b7ebSMike Smith static int
38723a31b7ebSMike Smith ciss_notify_abort_bmic(struct ciss_softc *sc)
38733a31b7ebSMike Smith {
38743a31b7ebSMike Smith     struct ciss_request			*cr;
38753a31b7ebSMike Smith     int					error, command_status;
38763a31b7ebSMike Smith 
38773a31b7ebSMike Smith     debug_called(1);
38783a31b7ebSMike Smith 
38793a31b7ebSMike Smith     cr = NULL;
38803a31b7ebSMike Smith     error = 0;
38813a31b7ebSMike Smith 
38823a31b7ebSMike Smith     /* verify that there's an outstanding command */
38833a31b7ebSMike Smith     if (!(sc->ciss_flags & CISS_FLAG_NOTIFY_OK))
38843a31b7ebSMike Smith 	goto out;
38853a31b7ebSMike Smith 
38863a31b7ebSMike Smith     /*
38873a31b7ebSMike Smith      * Build a BMIC command to cancel the Notify on Event command.
38883a31b7ebSMike Smith      *
38893a31b7ebSMike Smith      * Note that we are sending a CISS opcode here.  Odd.
38903a31b7ebSMike Smith      */
38913a31b7ebSMike Smith     if ((error = ciss_get_bmic_request(sc, &cr, CISS_COMMAND_ABORT_NOTIFY,
38923a31b7ebSMike Smith 				       NULL, 0)) != 0)
38933a31b7ebSMike Smith 	goto out;
38943a31b7ebSMike Smith 
38953a31b7ebSMike Smith     /*
38963a31b7ebSMike Smith      * Submit the request and wait for it to complete.
38973a31b7ebSMike Smith      */
38983a31b7ebSMike Smith     if ((error = ciss_synch_request(cr, 60 * 1000)) != 0) {
38993a31b7ebSMike Smith 	ciss_printf(sc, "error sending BMIC Cancel Notify on Event command (%d)\n", error);
39003a31b7ebSMike Smith 	goto out;
39013a31b7ebSMike Smith     }
39023a31b7ebSMike Smith 
39033a31b7ebSMike Smith     /*
39043a31b7ebSMike Smith      * Check response.
39053a31b7ebSMike Smith      */
39063a31b7ebSMike Smith     ciss_report_request(cr, &command_status, NULL);
39073a31b7ebSMike Smith     switch(command_status) {
39083a31b7ebSMike Smith     case CISS_CMD_STATUS_SUCCESS:
39093a31b7ebSMike Smith 	break;
39103a31b7ebSMike Smith     default:
39113a31b7ebSMike Smith 	ciss_printf(sc, "error cancelling Notify on Event (%s)\n",
39123a31b7ebSMike Smith 		    ciss_name_command_status(command_status));
39133a31b7ebSMike Smith 	error = EIO;
39143a31b7ebSMike Smith 	goto out;
39153a31b7ebSMike Smith     }
39163a31b7ebSMike Smith 
39173a31b7ebSMike Smith out:
39183a31b7ebSMike Smith     if (cr != NULL)
39193a31b7ebSMike Smith 	ciss_release_request(cr);
39203a31b7ebSMike Smith     return(error);
39213a31b7ebSMike Smith }
39223a31b7ebSMike Smith 
39233a31b7ebSMike Smith /************************************************************************
3924c6131460SPaul Saab  * Handle rescanning all the logical volumes when a notify event
3925c6131460SPaul Saab  * causes the drives to come online or offline.
3926c6131460SPaul Saab  */
3927c6131460SPaul Saab static void
3928c6131460SPaul Saab ciss_notify_rescan_logical(struct ciss_softc *sc)
3929c6131460SPaul Saab {
3930c6131460SPaul Saab     struct ciss_lun_report      *cll;
3931c6131460SPaul Saab     struct ciss_ldrive		*ld;
3932c6131460SPaul Saab     int                         i, j, ndrives;
3933c6131460SPaul Saab 
3934c6131460SPaul Saab     /*
3935c6131460SPaul Saab      * We must rescan all logical volumes to get the right logical
3936c6131460SPaul Saab      * drive address.
3937c6131460SPaul Saab      */
3938c6131460SPaul Saab     cll = ciss_report_luns(sc, CISS_OPCODE_REPORT_LOGICAL_LUNS,
3939e3edca22SSean Bruno                            sc->ciss_cfg->max_logical_supported);
3940c6131460SPaul Saab     if (cll == NULL)
3941c6131460SPaul Saab         return;
3942c6131460SPaul Saab 
3943c6131460SPaul Saab     ndrives = (ntohl(cll->list_size) / sizeof(union ciss_device_address));
3944c6131460SPaul Saab 
3945c6131460SPaul Saab     /*
3946c6131460SPaul Saab      * Delete any of the drives which were destroyed by the
3947c6131460SPaul Saab      * firmware.
3948c6131460SPaul Saab      */
39491fe6c4eeSScott Long     for (i = 0; i < sc->ciss_max_logical_bus; i++) {
3950e3edca22SSean Bruno 	for (j = 0; j < sc->ciss_cfg->max_logical_supported; j++) {
3951c6131460SPaul Saab 	    ld = &sc->ciss_logical[i][j];
3952c6131460SPaul Saab 
3953c6131460SPaul Saab 	    if (ld->cl_update == 0)
3954c6131460SPaul Saab 		continue;
3955c6131460SPaul Saab 
3956c6131460SPaul Saab 	    if (ld->cl_status != CISS_LD_ONLINE) {
3957c6131460SPaul Saab 		ciss_cam_rescan_target(sc, i, j);
3958c6131460SPaul Saab 		ld->cl_update = 0;
3959c6131460SPaul Saab 		if (ld->cl_ldrive)
3960c6131460SPaul Saab 		    free(ld->cl_ldrive, CISS_MALLOC_CLASS);
3961c6131460SPaul Saab 		if (ld->cl_lstatus)
3962c6131460SPaul Saab 		    free(ld->cl_lstatus, CISS_MALLOC_CLASS);
3963c6131460SPaul Saab 
3964c6131460SPaul Saab 		ld->cl_ldrive = NULL;
3965c6131460SPaul Saab 		ld->cl_lstatus = NULL;
3966c6131460SPaul Saab 	    }
3967c6131460SPaul Saab 	}
3968c6131460SPaul Saab     }
3969c6131460SPaul Saab 
3970c6131460SPaul Saab     /*
3971c6131460SPaul Saab      * Scan for new drives.
3972c6131460SPaul Saab      */
3973c6131460SPaul Saab     for (i = 0; i < ndrives; i++) {
3974c6131460SPaul Saab 	int	bus, target;
3975c6131460SPaul Saab 
3976c6131460SPaul Saab 	bus 	= CISS_LUN_TO_BUS(cll->lun[i].logical.lun);
3977c6131460SPaul Saab 	target	= CISS_LUN_TO_TARGET(cll->lun[i].logical.lun);
3978c6131460SPaul Saab 	ld	= &sc->ciss_logical[bus][target];
3979c6131460SPaul Saab 
3980c6131460SPaul Saab 	if (ld->cl_update == 0)
3981c6131460SPaul Saab 		continue;
3982c6131460SPaul Saab 
39835cf5a430SPaul Saab 	ld->cl_update		= 0;
3984c6131460SPaul Saab 	ld->cl_address		= cll->lun[i];
3985c6131460SPaul Saab 	ld->cl_controller	= &sc->ciss_controllers[bus];
3986c6131460SPaul Saab 	if (ciss_identify_logical(sc, ld) == 0) {
3987c6131460SPaul Saab 	    ciss_cam_rescan_target(sc, bus, target);
3988c6131460SPaul Saab 	}
3989c6131460SPaul Saab     }
3990c6131460SPaul Saab     free(cll, CISS_MALLOC_CLASS);
3991c6131460SPaul Saab }
3992c6131460SPaul Saab 
3993c6131460SPaul Saab /************************************************************************
39943a31b7ebSMike Smith  * Handle a notify event relating to the status of a logical drive.
39953a31b7ebSMike Smith  *
39963a31b7ebSMike Smith  * XXX need to be able to defer some of these to properly handle
39973a31b7ebSMike Smith  *     calling the "ID Physical drive" command, unless the 'extended'
39983a31b7ebSMike Smith  *     drive IDs are always in BIG_MAP format.
39993a31b7ebSMike Smith  */
40003a31b7ebSMike Smith static void
40013a31b7ebSMike Smith ciss_notify_logical(struct ciss_softc *sc, struct ciss_notify *cn)
40023a31b7ebSMike Smith {
40033a31b7ebSMike Smith     struct ciss_ldrive	*ld;
4004e6aa1412SSean Bruno     int			ostatus, bus, target;
40053a31b7ebSMike Smith 
40063a31b7ebSMike Smith     debug_called(2);
40073a31b7ebSMike Smith 
4008c6131460SPaul Saab     bus		= cn->device.physical.bus;
4009c6131460SPaul Saab     target	= cn->data.logical_status.logical_drive;
4010c6131460SPaul Saab     ld		= &sc->ciss_logical[bus][target];
40113a31b7ebSMike Smith 
40123a31b7ebSMike Smith     switch (cn->subclass) {
40133a31b7ebSMike Smith     case CISS_NOTIFY_LOGICAL_STATUS:
40143a31b7ebSMike Smith 	switch (cn->detail) {
40153a31b7ebSMike Smith 	case 0:
4016c6131460SPaul Saab 	    ciss_name_device(sc, bus, target);
40173a31b7ebSMike Smith 	    ciss_printf(sc, "logical drive %d (%s) changed status %s->%s, spare status 0x%b\n",
40183a31b7ebSMike Smith 			cn->data.logical_status.logical_drive, ld->cl_name,
40193a31b7ebSMike Smith 			ciss_name_ldrive_status(cn->data.logical_status.previous_state),
40203a31b7ebSMike Smith 			ciss_name_ldrive_status(cn->data.logical_status.new_state),
40213a31b7ebSMike Smith 			cn->data.logical_status.spare_state,
40223a31b7ebSMike Smith 			"\20\1configured\2rebuilding\3failed\4in use\5available\n");
40233a31b7ebSMike Smith 
40243a31b7ebSMike Smith 	    /*
40253a31b7ebSMike Smith 	     * Update our idea of the drive's status.
40263a31b7ebSMike Smith 	     */
4027e6aa1412SSean Bruno 	    ostatus = ciss_decode_ldrive_status(cn->data.logical_status.previous_state);
40283a31b7ebSMike Smith 	    ld->cl_status = ciss_decode_ldrive_status(cn->data.logical_status.new_state);
4029d4aa427fSPaul Saab 	    if (ld->cl_lstatus != NULL)
40303a31b7ebSMike Smith 		ld->cl_lstatus->status = cn->data.logical_status.new_state;
40313a31b7ebSMike Smith 
4032d4aa427fSPaul Saab 	    /*
4033d4aa427fSPaul Saab 	     * Have CAM rescan the drive if its status has changed.
4034d4aa427fSPaul Saab 	     */
4035e6aa1412SSean Bruno 	    if (ostatus != ld->cl_status) {
4036c6131460SPaul Saab 		ld->cl_update = 1;
4037c6131460SPaul Saab 		ciss_notify_rescan_logical(sc);
4038c6131460SPaul Saab 	    }
4039d4aa427fSPaul Saab 
40403a31b7ebSMike Smith 	    break;
40413a31b7ebSMike Smith 
40423a31b7ebSMike Smith 	case 1:	/* logical drive has recognised new media, needs Accept Media Exchange */
4043c6131460SPaul Saab 	    ciss_name_device(sc, bus, target);
40443a31b7ebSMike Smith 	    ciss_printf(sc, "logical drive %d (%s) media exchanged, ready to go online\n",
40453a31b7ebSMike Smith 			cn->data.logical_status.logical_drive, ld->cl_name);
404688c78a38SPaul Saab 	    ciss_accept_media(sc, ld);
4047139233cbSPaul Saab 
4048139233cbSPaul Saab 	    ld->cl_update = 1;
4049139233cbSPaul Saab 	    ld->cl_status = ciss_decode_ldrive_status(cn->data.logical_status.new_state);
4050139233cbSPaul Saab 	    ciss_notify_rescan_logical(sc);
40513a31b7ebSMike Smith 	    break;
40523a31b7ebSMike Smith 
40533a31b7ebSMike Smith 	case 2:
40543a31b7ebSMike Smith 	case 3:
40553a31b7ebSMike Smith 	    ciss_printf(sc, "rebuild of logical drive %d (%s) failed due to %s error\n",
40563a31b7ebSMike Smith 			cn->data.rebuild_aborted.logical_drive,
4057c6131460SPaul Saab 			ld->cl_name,
40583a31b7ebSMike Smith 			(cn->detail == 2) ? "read" : "write");
40593a31b7ebSMike Smith 	    break;
40603a31b7ebSMike Smith 	}
40613a31b7ebSMike Smith 	break;
40623a31b7ebSMike Smith 
40633a31b7ebSMike Smith     case CISS_NOTIFY_LOGICAL_ERROR:
40643a31b7ebSMike Smith 	if (cn->detail == 0) {
40653a31b7ebSMike Smith 	    ciss_printf(sc, "FATAL I/O ERROR on logical drive %d (%s), SCSI port %d ID %d\n",
40663a31b7ebSMike Smith 			cn->data.io_error.logical_drive,
4067c6131460SPaul Saab 			ld->cl_name,
40683a31b7ebSMike Smith 			cn->data.io_error.failure_bus,
40693a31b7ebSMike Smith 			cn->data.io_error.failure_drive);
40703a31b7ebSMike Smith 	    /* XXX should we take the drive down at this point, or will we be told? */
40713a31b7ebSMike Smith 	}
40723a31b7ebSMike Smith 	break;
40733a31b7ebSMike Smith 
40743a31b7ebSMike Smith     case CISS_NOTIFY_LOGICAL_SURFACE:
40753a31b7ebSMike Smith 	if (cn->detail == 0)
40763a31b7ebSMike Smith 	    ciss_printf(sc, "logical drive %d (%s) completed consistency initialisation\n",
40773a31b7ebSMike Smith 			cn->data.consistency_completed.logical_drive,
4078c6131460SPaul Saab 			ld->cl_name);
40793a31b7ebSMike Smith 	break;
40803a31b7ebSMike Smith     }
40813a31b7ebSMike Smith }
40823a31b7ebSMike Smith 
40833a31b7ebSMike Smith /************************************************************************
40843a31b7ebSMike Smith  * Handle a notify event relating to the status of a physical drive.
40853a31b7ebSMike Smith  */
40863a31b7ebSMike Smith static void
40873a31b7ebSMike Smith ciss_notify_physical(struct ciss_softc *sc, struct ciss_notify *cn)
40883a31b7ebSMike Smith {
4089c6131460SPaul Saab }
40903a31b7ebSMike Smith 
4091c6131460SPaul Saab /************************************************************************
40921fe6c4eeSScott Long  * Handle a notify event relating to the status of a physical drive.
40931fe6c4eeSScott Long  */
40941fe6c4eeSScott Long static void
40951fe6c4eeSScott Long ciss_notify_hotplug(struct ciss_softc *sc, struct ciss_notify *cn)
40961fe6c4eeSScott Long {
4097c1885ab8SPaul Saab     struct ciss_lun_report *cll = NULL;
40981fe6c4eeSScott Long     int bus, target;
40991fe6c4eeSScott Long 
41001fe6c4eeSScott Long     switch (cn->subclass) {
41011fe6c4eeSScott Long     case CISS_NOTIFY_HOTPLUG_PHYSICAL:
41021fe6c4eeSScott Long     case CISS_NOTIFY_HOTPLUG_NONDISK:
41031fe6c4eeSScott Long 	bus = CISS_BIG_MAP_BUS(sc, cn->data.drive.big_physical_drive_number);
41041fe6c4eeSScott Long 	target =
41051fe6c4eeSScott Long 	    CISS_BIG_MAP_TARGET(sc, cn->data.drive.big_physical_drive_number);
41061fe6c4eeSScott Long 
41071fe6c4eeSScott Long 	if (cn->detail == 0) {
41081fe6c4eeSScott Long 	    /*
41091fe6c4eeSScott Long 	     * Mark the device offline so that it'll start producing selection
41101fe6c4eeSScott Long 	     * timeouts to the upper layer.
41111fe6c4eeSScott Long 	     */
41125f265711SScott Long 	    if ((bus >= 0) && (target >= 0))
41131fe6c4eeSScott Long 		sc->ciss_physical[bus][target].cp_online = 0;
41141fe6c4eeSScott Long 	} else {
41151fe6c4eeSScott Long 	    /*
41161fe6c4eeSScott Long 	     * Rescan the physical lun list for new items
41171fe6c4eeSScott Long 	     */
41181fe6c4eeSScott Long 	    cll = ciss_report_luns(sc, CISS_OPCODE_REPORT_PHYSICAL_LUNS,
4119e3edca22SSean Bruno 				   sc->ciss_cfg->max_physical_supported);
41201fe6c4eeSScott Long 	    if (cll == NULL) {
41211fe6c4eeSScott Long 		ciss_printf(sc, "Warning, cannot get physical lun list\n");
41221fe6c4eeSScott Long 		break;
41231fe6c4eeSScott Long 	    }
41241fe6c4eeSScott Long 	    ciss_filter_physical(sc, cll);
41251fe6c4eeSScott Long 	}
41261fe6c4eeSScott Long 	break;
41271fe6c4eeSScott Long 
41281fe6c4eeSScott Long     default:
41291fe6c4eeSScott Long 	ciss_printf(sc, "Unknown hotplug event %d\n", cn->subclass);
41301fe6c4eeSScott Long 	return;
41311fe6c4eeSScott Long     }
4132c1885ab8SPaul Saab 
4133c1885ab8SPaul Saab     if (cll != NULL)
4134c1885ab8SPaul Saab 	free(cll, CISS_MALLOC_CLASS);
41351fe6c4eeSScott Long }
41361fe6c4eeSScott Long 
41371fe6c4eeSScott Long /************************************************************************
4138c6131460SPaul Saab  * Handle deferred processing of notify events.  Notify events may need
4139c6131460SPaul Saab  * sleep which is unsafe during an interrupt.
4140c6131460SPaul Saab  */
4141c6131460SPaul Saab static void
4142c6131460SPaul Saab ciss_notify_thread(void *arg)
4143c6131460SPaul Saab {
4144c6131460SPaul Saab     struct ciss_softc		*sc;
4145c6131460SPaul Saab     struct ciss_request		*cr;
4146c6131460SPaul Saab     struct ciss_notify		*cn;
4147c6131460SPaul Saab 
4148c6131460SPaul Saab     sc = (struct ciss_softc *)arg;
4149975b7318SScott Long     mtx_lock(&sc->ciss_mtx);
4150c6131460SPaul Saab 
4151c6131460SPaul Saab     for (;;) {
415222657ce1SScott Long 	if (STAILQ_EMPTY(&sc->ciss_notify) != 0 &&
4153c6131460SPaul Saab 	    (sc->ciss_flags & CISS_FLAG_THREAD_SHUT) == 0) {
4154975b7318SScott Long 	    msleep(&sc->ciss_notify, &sc->ciss_mtx, PUSER, "idle", 0);
4155c6131460SPaul Saab 	}
4156c6131460SPaul Saab 
4157c6131460SPaul Saab 	if (sc->ciss_flags & CISS_FLAG_THREAD_SHUT)
4158c6131460SPaul Saab 	    break;
4159c6131460SPaul Saab 
4160c6131460SPaul Saab 	cr = ciss_dequeue_notify(sc);
4161c6131460SPaul Saab 
4162c6131460SPaul Saab 	if (cr == NULL)
4163c6131460SPaul Saab 		panic("cr null");
4164c6131460SPaul Saab 	cn = (struct ciss_notify *)cr->cr_data;
4165c6131460SPaul Saab 
4166c6131460SPaul Saab 	switch (cn->class) {
41671fe6c4eeSScott Long 	case CISS_NOTIFY_HOTPLUG:
41681fe6c4eeSScott Long 	    ciss_notify_hotplug(sc, cn);
41691fe6c4eeSScott Long 	    break;
4170c6131460SPaul Saab 	case CISS_NOTIFY_LOGICAL:
4171c6131460SPaul Saab 	    ciss_notify_logical(sc, cn);
4172c6131460SPaul Saab 	    break;
4173c6131460SPaul Saab 	case CISS_NOTIFY_PHYSICAL:
4174c6131460SPaul Saab 	    ciss_notify_physical(sc, cn);
4175c6131460SPaul Saab 	    break;
4176c6131460SPaul Saab 	}
4177c6131460SPaul Saab 
4178c6131460SPaul Saab 	ciss_release_request(cr);
4179c6131460SPaul Saab     }
4180c6131460SPaul Saab     sc->ciss_notify_thread = NULL;
4181c6131460SPaul Saab     wakeup(&sc->ciss_notify_thread);
4182c6131460SPaul Saab 
4183975b7318SScott Long     mtx_unlock(&sc->ciss_mtx);
41843745c395SJulian Elischer     kproc_exit(0);
4185c6131460SPaul Saab }
4186c6131460SPaul Saab 
4187c6131460SPaul Saab /************************************************************************
4188c6131460SPaul Saab  * Start the notification kernel thread.
4189c6131460SPaul Saab  */
4190c6131460SPaul Saab static void
4191c6131460SPaul Saab ciss_spawn_notify_thread(struct ciss_softc *sc)
4192c6131460SPaul Saab {
4193c6131460SPaul Saab 
41943745c395SJulian Elischer     if (kproc_create((void(*)(void *))ciss_notify_thread, sc,
4195c6131460SPaul Saab 		       &sc->ciss_notify_thread, 0, 0, "ciss_notify%d",
4196c6131460SPaul Saab 		       device_get_unit(sc->ciss_dev)))
4197c6131460SPaul Saab 	panic("Could not create notify thread\n");
4198c6131460SPaul Saab }
4199c6131460SPaul Saab 
4200c6131460SPaul Saab /************************************************************************
4201c6131460SPaul Saab  * Kill the notification kernel thread.
4202c6131460SPaul Saab  */
4203c6131460SPaul Saab static void
4204c6131460SPaul Saab ciss_kill_notify_thread(struct ciss_softc *sc)
4205c6131460SPaul Saab {
4206c6131460SPaul Saab 
4207c6131460SPaul Saab     if (sc->ciss_notify_thread == NULL)
4208c6131460SPaul Saab 	return;
4209c6131460SPaul Saab 
4210c6131460SPaul Saab     sc->ciss_flags |= CISS_FLAG_THREAD_SHUT;
4211c6131460SPaul Saab     wakeup(&sc->ciss_notify);
4212975b7318SScott Long     msleep(&sc->ciss_notify_thread, &sc->ciss_mtx, PUSER, "thtrm", 0);
42133a31b7ebSMike Smith }
42143a31b7ebSMike Smith 
42153a31b7ebSMike Smith /************************************************************************
42163a31b7ebSMike Smith  * Print a request.
42173a31b7ebSMike Smith  */
42182e3d6d0fSWarner Losh #ifdef DDB
42193a31b7ebSMike Smith static void
42203a31b7ebSMike Smith ciss_print_request(struct ciss_request *cr)
42213a31b7ebSMike Smith {
42223a31b7ebSMike Smith     struct ciss_softc	*sc;
42233a31b7ebSMike Smith     struct ciss_command	*cc;
42243a31b7ebSMike Smith     int			i;
42253a31b7ebSMike Smith 
42263a31b7ebSMike Smith     sc = cr->cr_sc;
42272fdaa90dSScott Long     cc = cr->cr_cc;
42283a31b7ebSMike Smith 
42293a31b7ebSMike Smith     ciss_printf(sc, "REQUEST @ %p\n", cr);
42303a31b7ebSMike Smith     ciss_printf(sc, "  data %p/%d  tag %d  flags %b\n",
42313a31b7ebSMike Smith 	      cr->cr_data, cr->cr_length, cr->cr_tag, cr->cr_flags,
42323a31b7ebSMike Smith 	      "\20\1mapped\2sleep\3poll\4dataout\5datain\n");
42333a31b7ebSMike Smith     ciss_printf(sc, "  sg list/total %d/%d  host tag 0x%x\n",
42343a31b7ebSMike Smith 		cc->header.sg_in_list, cc->header.sg_total, cc->header.host_tag);
42353a31b7ebSMike Smith     switch(cc->header.address.mode.mode) {
42363a31b7ebSMike Smith     case CISS_HDR_ADDRESS_MODE_PERIPHERAL:
42373a31b7ebSMike Smith     case CISS_HDR_ADDRESS_MODE_MASK_PERIPHERAL:
42383a31b7ebSMike Smith 	ciss_printf(sc, "  physical bus %d target %d\n",
42393a31b7ebSMike Smith 		    cc->header.address.physical.bus, cc->header.address.physical.target);
42403a31b7ebSMike Smith 	break;
42413a31b7ebSMike Smith     case CISS_HDR_ADDRESS_MODE_LOGICAL:
42423a31b7ebSMike Smith 	ciss_printf(sc, "  logical unit %d\n", cc->header.address.logical.lun);
42433a31b7ebSMike Smith 	break;
42443a31b7ebSMike Smith     }
42453a31b7ebSMike Smith     ciss_printf(sc, "  %s cdb length %d type %s attribute %s\n",
42463a31b7ebSMike Smith 		(cc->cdb.direction == CISS_CDB_DIRECTION_NONE) ? "no-I/O" :
42473a31b7ebSMike Smith 		(cc->cdb.direction == CISS_CDB_DIRECTION_READ) ? "READ" :
42483a31b7ebSMike Smith 		(cc->cdb.direction == CISS_CDB_DIRECTION_WRITE) ? "WRITE" : "??",
42493a31b7ebSMike Smith 		cc->cdb.cdb_length,
42503a31b7ebSMike Smith 		(cc->cdb.type == CISS_CDB_TYPE_COMMAND) ? "command" :
42513a31b7ebSMike Smith 		(cc->cdb.type == CISS_CDB_TYPE_MESSAGE) ? "message" : "??",
42523a31b7ebSMike Smith 		(cc->cdb.attribute == CISS_CDB_ATTRIBUTE_UNTAGGED) ? "untagged" :
42533a31b7ebSMike Smith 		(cc->cdb.attribute == CISS_CDB_ATTRIBUTE_SIMPLE) ? "simple" :
42543a31b7ebSMike Smith 		(cc->cdb.attribute == CISS_CDB_ATTRIBUTE_HEAD_OF_QUEUE) ? "head-of-queue" :
42553a31b7ebSMike Smith 		(cc->cdb.attribute == CISS_CDB_ATTRIBUTE_ORDERED) ? "ordered" :
42563a31b7ebSMike Smith 		(cc->cdb.attribute == CISS_CDB_ATTRIBUTE_AUTO_CONTINGENT) ? "auto-contingent" : "??");
42573a31b7ebSMike Smith     ciss_printf(sc, "  %*D\n", cc->cdb.cdb_length, &cc->cdb.cdb[0], " ");
42583a31b7ebSMike Smith 
42593a31b7ebSMike Smith     if (cc->header.host_tag & CISS_HDR_HOST_TAG_ERROR) {
42603a31b7ebSMike Smith 	/* XXX print error info */
42613a31b7ebSMike Smith     } else {
42623a31b7ebSMike Smith 	/* since we don't use chained s/g, don't support it here */
42633a31b7ebSMike Smith 	for (i = 0; i < cc->header.sg_in_list; i++) {
42643a31b7ebSMike Smith 	    if ((i % 4) == 0)
42653a31b7ebSMike Smith 		ciss_printf(sc, "   ");
42663a31b7ebSMike Smith 	    printf("0x%08x/%d ", (u_int32_t)cc->sg[i].address, cc->sg[i].length);
42673a31b7ebSMike Smith 	    if ((((i + 1) % 4) == 0) || (i == (cc->header.sg_in_list - 1)))
42683a31b7ebSMike Smith 		printf("\n");
42693a31b7ebSMike Smith 	}
42703a31b7ebSMike Smith     }
42713a31b7ebSMike Smith }
42722e3d6d0fSWarner Losh #endif
42733a31b7ebSMike Smith 
42743a31b7ebSMike Smith /************************************************************************
42753a31b7ebSMike Smith  * Print information about the status of a logical drive.
42763a31b7ebSMike Smith  */
42773a31b7ebSMike Smith static void
42783a31b7ebSMike Smith ciss_print_ldrive(struct ciss_softc *sc, struct ciss_ldrive *ld)
42793a31b7ebSMike Smith {
42803a31b7ebSMike Smith     int		bus, target, i;
42813a31b7ebSMike Smith 
4282d4aa427fSPaul Saab     if (ld->cl_lstatus == NULL) {
4283d4aa427fSPaul Saab 	printf("does not exist\n");
4284d4aa427fSPaul Saab 	return;
4285d4aa427fSPaul Saab     }
4286d4aa427fSPaul Saab 
42873a31b7ebSMike Smith     /* print drive status */
42883a31b7ebSMike Smith     switch(ld->cl_lstatus->status) {
42893a31b7ebSMike Smith     case CISS_LSTATUS_OK:
42903a31b7ebSMike Smith 	printf("online\n");
42913a31b7ebSMike Smith 	break;
42923a31b7ebSMike Smith     case CISS_LSTATUS_INTERIM_RECOVERY:
42933a31b7ebSMike Smith 	printf("in interim recovery mode\n");
42943a31b7ebSMike Smith 	break;
42953a31b7ebSMike Smith     case CISS_LSTATUS_READY_RECOVERY:
42963a31b7ebSMike Smith 	printf("ready to begin recovery\n");
42973a31b7ebSMike Smith 	break;
42983a31b7ebSMike Smith     case CISS_LSTATUS_RECOVERING:
42993a31b7ebSMike Smith 	bus = CISS_BIG_MAP_BUS(sc, ld->cl_lstatus->drive_rebuilding);
43003a31b7ebSMike Smith 	target = CISS_BIG_MAP_BUS(sc, ld->cl_lstatus->drive_rebuilding);
43013a31b7ebSMike Smith 	printf("being recovered, working on physical drive %d.%d, %u blocks remaining\n",
43023a31b7ebSMike Smith 	       bus, target, ld->cl_lstatus->blocks_to_recover);
43033a31b7ebSMike Smith 	break;
43043a31b7ebSMike Smith     case CISS_LSTATUS_EXPANDING:
43053a31b7ebSMike Smith 	printf("being expanded, %u blocks remaining\n",
43063a31b7ebSMike Smith 	       ld->cl_lstatus->blocks_to_recover);
43073a31b7ebSMike Smith 	break;
43083a31b7ebSMike Smith     case CISS_LSTATUS_QUEUED_FOR_EXPANSION:
43093a31b7ebSMike Smith 	printf("queued for expansion\n");
43103a31b7ebSMike Smith 	break;
43113a31b7ebSMike Smith     case CISS_LSTATUS_FAILED:
43123a31b7ebSMike Smith 	printf("queued for expansion\n");
43133a31b7ebSMike Smith 	break;
43143a31b7ebSMike Smith     case CISS_LSTATUS_WRONG_PDRIVE:
43153a31b7ebSMike Smith 	printf("wrong physical drive inserted\n");
43163a31b7ebSMike Smith 	break;
43173a31b7ebSMike Smith     case CISS_LSTATUS_MISSING_PDRIVE:
43183a31b7ebSMike Smith 	printf("missing a needed physical drive\n");
43193a31b7ebSMike Smith 	break;
43203a31b7ebSMike Smith     case CISS_LSTATUS_BECOMING_READY:
43213a31b7ebSMike Smith 	printf("becoming ready\n");
43223a31b7ebSMike Smith 	break;
43233a31b7ebSMike Smith     }
43243a31b7ebSMike Smith 
4325d4aa427fSPaul Saab     /* print failed physical drives */
43263a31b7ebSMike Smith     for (i = 0; i < CISS_BIG_MAP_ENTRIES / 8; i++) {
43273a31b7ebSMike Smith 	bus = CISS_BIG_MAP_BUS(sc, ld->cl_lstatus->drive_failure_map[i]);
43283a31b7ebSMike Smith 	target = CISS_BIG_MAP_TARGET(sc, ld->cl_lstatus->drive_failure_map[i]);
43293a31b7ebSMike Smith 	if (bus == -1)
43303a31b7ebSMike Smith 	    continue;
43313a31b7ebSMike Smith 	ciss_printf(sc, "physical drive %d:%d (%x) failed\n", bus, target,
43323a31b7ebSMike Smith 		    ld->cl_lstatus->drive_failure_map[i]);
43333a31b7ebSMike Smith     }
43343a31b7ebSMike Smith }
43353a31b7ebSMike Smith 
4336b27556e0SSean Bruno #ifdef DDB
4337b27556e0SSean Bruno #include <ddb/ddb.h>
4338d4aa427fSPaul Saab /************************************************************************
4339d4aa427fSPaul Saab  * Print information about the controller/driver.
4340d4aa427fSPaul Saab  */
4341d4aa427fSPaul Saab static void
4342d4aa427fSPaul Saab ciss_print_adapter(struct ciss_softc *sc)
4343d4aa427fSPaul Saab {
4344609caf8dSPaul Saab     int		i, j;
4345d4aa427fSPaul Saab 
4346d4aa427fSPaul Saab     ciss_printf(sc, "ADAPTER:\n");
4347d4aa427fSPaul Saab     for (i = 0; i < CISSQ_COUNT; i++) {
4348d4aa427fSPaul Saab 	ciss_printf(sc, "%s     %d/%d\n",
4349d4aa427fSPaul Saab 	    i == 0 ? "free" :
4350d4aa427fSPaul Saab 	    i == 1 ? "busy" : "complete",
4351d4aa427fSPaul Saab 	    sc->ciss_qstat[i].q_length,
4352d4aa427fSPaul Saab 	    sc->ciss_qstat[i].q_max);
4353d4aa427fSPaul Saab     }
4354d4aa427fSPaul Saab     ciss_printf(sc, "max_requests %d\n", sc->ciss_max_requests);
4355d4aa427fSPaul Saab     ciss_printf(sc, "flags %b\n", sc->ciss_flags,
4356d4aa427fSPaul Saab 	"\20\1notify_ok\2control_open\3aborting\4running\21fake_synch\22bmic_abort\n");
4357d4aa427fSPaul Saab 
43581fe6c4eeSScott Long     for (i = 0; i < sc->ciss_max_logical_bus; i++) {
4359e3edca22SSean Bruno 	for (j = 0; j < sc->ciss_cfg->max_logical_supported; j++) {
4360d4aa427fSPaul Saab 	    ciss_printf(sc, "LOGICAL DRIVE %d:  ", i);
4361609caf8dSPaul Saab 	    ciss_print_ldrive(sc, &sc->ciss_logical[i][j]);
4362609caf8dSPaul Saab 	}
4363d4aa427fSPaul Saab     }
4364d4aa427fSPaul Saab 
43651fe6c4eeSScott Long     /* XXX Should physical drives be printed out here? */
43661fe6c4eeSScott Long 
4367d4aa427fSPaul Saab     for (i = 1; i < sc->ciss_max_requests; i++)
4368d4aa427fSPaul Saab 	ciss_print_request(sc->ciss_request + i);
4369d4aa427fSPaul Saab }
4370d4aa427fSPaul Saab 
4371d4aa427fSPaul Saab /* DDB hook */
4372b27556e0SSean Bruno DB_COMMAND(ciss_prt, db_ciss_prt)
4373d4aa427fSPaul Saab {
4374d4aa427fSPaul Saab     struct ciss_softc	*sc;
437511f9f6eaSSean Bruno     devclass_t dc;
437611f9f6eaSSean Bruno     int maxciss, i;
4377d4aa427fSPaul Saab 
437811f9f6eaSSean Bruno     dc = devclass_find("ciss");
437911f9f6eaSSean Bruno     if ( dc == NULL ) {
438011f9f6eaSSean Bruno         printf("%s: can't find devclass!\n", __func__);
438111f9f6eaSSean Bruno         return;
438211f9f6eaSSean Bruno     }
438311f9f6eaSSean Bruno     maxciss = devclass_get_maxunit(dc);
438411f9f6eaSSean Bruno     for (i = 0; i < maxciss; i++) {
438511f9f6eaSSean Bruno         sc = devclass_get_softc(dc, i);
4386d4aa427fSPaul Saab 	ciss_print_adapter(sc);
4387d4aa427fSPaul Saab     }
4388d4aa427fSPaul Saab }
4389d4aa427fSPaul Saab #endif
4390d4aa427fSPaul Saab 
43913a31b7ebSMike Smith /************************************************************************
43923a31b7ebSMike Smith  * Return a name for a logical drive status value.
43933a31b7ebSMike Smith  */
43943a31b7ebSMike Smith static const char *
43953a31b7ebSMike Smith ciss_name_ldrive_status(int status)
43963a31b7ebSMike Smith {
43973a31b7ebSMike Smith     switch (status) {
43983a31b7ebSMike Smith     case CISS_LSTATUS_OK:
43993a31b7ebSMike Smith 	return("OK");
44003a31b7ebSMike Smith     case CISS_LSTATUS_FAILED:
44013a31b7ebSMike Smith 	return("failed");
44023a31b7ebSMike Smith     case CISS_LSTATUS_NOT_CONFIGURED:
44033a31b7ebSMike Smith 	return("not configured");
44043a31b7ebSMike Smith     case CISS_LSTATUS_INTERIM_RECOVERY:
44053a31b7ebSMike Smith 	return("interim recovery");
44063a31b7ebSMike Smith     case CISS_LSTATUS_READY_RECOVERY:
44073a31b7ebSMike Smith 	return("ready for recovery");
44083a31b7ebSMike Smith     case CISS_LSTATUS_RECOVERING:
44093a31b7ebSMike Smith 	return("recovering");
44103a31b7ebSMike Smith     case CISS_LSTATUS_WRONG_PDRIVE:
44113a31b7ebSMike Smith 	return("wrong physical drive inserted");
44123a31b7ebSMike Smith     case CISS_LSTATUS_MISSING_PDRIVE:
44133a31b7ebSMike Smith 	return("missing physical drive");
44143a31b7ebSMike Smith     case CISS_LSTATUS_EXPANDING:
44153a31b7ebSMike Smith 	return("expanding");
44163a31b7ebSMike Smith     case CISS_LSTATUS_BECOMING_READY:
44173a31b7ebSMike Smith 	return("becoming ready");
44183a31b7ebSMike Smith     case CISS_LSTATUS_QUEUED_FOR_EXPANSION:
44193a31b7ebSMike Smith 	return("queued for expansion");
44203a31b7ebSMike Smith     }
44213a31b7ebSMike Smith     return("unknown status");
44223a31b7ebSMike Smith }
44233a31b7ebSMike Smith 
44243a31b7ebSMike Smith /************************************************************************
44253a31b7ebSMike Smith  * Return an online/offline/nonexistent value for a logical drive
44263a31b7ebSMike Smith  * status value.
44273a31b7ebSMike Smith  */
44283a31b7ebSMike Smith static int
44293a31b7ebSMike Smith ciss_decode_ldrive_status(int status)
44303a31b7ebSMike Smith {
44313a31b7ebSMike Smith     switch(status) {
44323a31b7ebSMike Smith     case CISS_LSTATUS_NOT_CONFIGURED:
44333a31b7ebSMike Smith 	return(CISS_LD_NONEXISTENT);
44343a31b7ebSMike Smith 
44353a31b7ebSMike Smith     case CISS_LSTATUS_OK:
44363a31b7ebSMike Smith     case CISS_LSTATUS_INTERIM_RECOVERY:
44373a31b7ebSMike Smith     case CISS_LSTATUS_READY_RECOVERY:
44383a31b7ebSMike Smith     case CISS_LSTATUS_RECOVERING:
44393a31b7ebSMike Smith     case CISS_LSTATUS_EXPANDING:
44403a31b7ebSMike Smith     case CISS_LSTATUS_QUEUED_FOR_EXPANSION:
44413a31b7ebSMike Smith 	return(CISS_LD_ONLINE);
44423a31b7ebSMike Smith 
44433a31b7ebSMike Smith     case CISS_LSTATUS_FAILED:
44443a31b7ebSMike Smith     case CISS_LSTATUS_WRONG_PDRIVE:
44453a31b7ebSMike Smith     case CISS_LSTATUS_MISSING_PDRIVE:
44463a31b7ebSMike Smith     case CISS_LSTATUS_BECOMING_READY:
44473a31b7ebSMike Smith     default:
44483a31b7ebSMike Smith 	return(CISS_LD_OFFLINE);
44493a31b7ebSMike Smith     }
44503a31b7ebSMike Smith }
44513a31b7ebSMike Smith 
44523a31b7ebSMike Smith /************************************************************************
44533a31b7ebSMike Smith  * Return a name for a logical drive's organisation.
44543a31b7ebSMike Smith  */
44553a31b7ebSMike Smith static const char *
44563a31b7ebSMike Smith ciss_name_ldrive_org(int org)
44573a31b7ebSMike Smith {
44583a31b7ebSMike Smith     switch(org) {
44593a31b7ebSMike Smith     case CISS_LDRIVE_RAID0:
44603a31b7ebSMike Smith 	return("RAID 0");
44613a31b7ebSMike Smith     case CISS_LDRIVE_RAID1:
4462d000b49dSKonstantin Belousov 	return("RAID 1(1+0)");
44633a31b7ebSMike Smith     case CISS_LDRIVE_RAID4:
44643a31b7ebSMike Smith 	return("RAID 4");
44653a31b7ebSMike Smith     case CISS_LDRIVE_RAID5:
44663a31b7ebSMike Smith 	return("RAID 5");
4467aaf8327bSPaul Saab     case CISS_LDRIVE_RAID51:
4468aaf8327bSPaul Saab 	return("RAID 5+1");
4469aaf8327bSPaul Saab     case CISS_LDRIVE_RAIDADG:
4470aaf8327bSPaul Saab 	return("RAID ADG");
44713a31b7ebSMike Smith     }
4472b790c193SPedro F. Giffuni     return("unknown");
44733a31b7ebSMike Smith }
44743a31b7ebSMike Smith 
44753a31b7ebSMike Smith /************************************************************************
44763a31b7ebSMike Smith  * Return a name for a command status value.
44773a31b7ebSMike Smith  */
44783a31b7ebSMike Smith static const char *
44793a31b7ebSMike Smith ciss_name_command_status(int status)
44803a31b7ebSMike Smith {
44813a31b7ebSMike Smith     switch(status) {
44823a31b7ebSMike Smith     case CISS_CMD_STATUS_SUCCESS:
44833a31b7ebSMike Smith 	return("success");
44843a31b7ebSMike Smith     case CISS_CMD_STATUS_TARGET_STATUS:
44853a31b7ebSMike Smith 	return("target status");
44863a31b7ebSMike Smith     case CISS_CMD_STATUS_DATA_UNDERRUN:
44873a31b7ebSMike Smith 	return("data underrun");
44883a31b7ebSMike Smith     case CISS_CMD_STATUS_DATA_OVERRUN:
44893a31b7ebSMike Smith 	return("data overrun");
44903a31b7ebSMike Smith     case CISS_CMD_STATUS_INVALID_COMMAND:
44913a31b7ebSMike Smith 	return("invalid command");
44923a31b7ebSMike Smith     case CISS_CMD_STATUS_PROTOCOL_ERROR:
44933a31b7ebSMike Smith 	return("protocol error");
44943a31b7ebSMike Smith     case CISS_CMD_STATUS_HARDWARE_ERROR:
44953a31b7ebSMike Smith 	return("hardware error");
44963a31b7ebSMike Smith     case CISS_CMD_STATUS_CONNECTION_LOST:
44973a31b7ebSMike Smith 	return("connection lost");
44983a31b7ebSMike Smith     case CISS_CMD_STATUS_ABORTED:
44993a31b7ebSMike Smith 	return("aborted");
45003a31b7ebSMike Smith     case CISS_CMD_STATUS_ABORT_FAILED:
45013a31b7ebSMike Smith 	return("abort failed");
45023a31b7ebSMike Smith     case CISS_CMD_STATUS_UNSOLICITED_ABORT:
45033a31b7ebSMike Smith 	return("unsolicited abort");
45043a31b7ebSMike Smith     case CISS_CMD_STATUS_TIMEOUT:
45053a31b7ebSMike Smith 	return("timeout");
45063a31b7ebSMike Smith     case CISS_CMD_STATUS_UNABORTABLE:
45073a31b7ebSMike Smith 	return("unabortable");
45083a31b7ebSMike Smith     }
45093a31b7ebSMike Smith     return("unknown status");
45103a31b7ebSMike Smith }
45113a31b7ebSMike Smith 
45123a31b7ebSMike Smith /************************************************************************
45133a31b7ebSMike Smith  * Handle an open on the control device.
45143a31b7ebSMike Smith  */
45153a31b7ebSMike Smith static int
451600b4e54aSWarner Losh ciss_open(struct cdev *dev, int flags, int fmt, struct thread *p)
45173a31b7ebSMike Smith {
45183a31b7ebSMike Smith     struct ciss_softc	*sc;
45193a31b7ebSMike Smith 
45203a31b7ebSMike Smith     debug_called(1);
45213a31b7ebSMike Smith 
45223a31b7ebSMike Smith     sc = (struct ciss_softc *)dev->si_drv1;
45233a31b7ebSMike Smith 
45243a31b7ebSMike Smith     /* we might want to veto if someone already has us open */
45253a31b7ebSMike Smith 
4526975b7318SScott Long     mtx_lock(&sc->ciss_mtx);
45273a31b7ebSMike Smith     sc->ciss_flags |= CISS_FLAG_CONTROL_OPEN;
4528975b7318SScott Long     mtx_unlock(&sc->ciss_mtx);
45293a31b7ebSMike Smith     return(0);
45303a31b7ebSMike Smith }
45313a31b7ebSMike Smith 
45323a31b7ebSMike Smith /************************************************************************
45333a31b7ebSMike Smith  * Handle the last close on the control device.
45343a31b7ebSMike Smith  */
45353a31b7ebSMike Smith static int
453600b4e54aSWarner Losh ciss_close(struct cdev *dev, int flags, int fmt, struct thread *p)
45373a31b7ebSMike Smith {
45383a31b7ebSMike Smith     struct ciss_softc	*sc;
45393a31b7ebSMike Smith 
45403a31b7ebSMike Smith     debug_called(1);
45413a31b7ebSMike Smith 
45423a31b7ebSMike Smith     sc = (struct ciss_softc *)dev->si_drv1;
45433a31b7ebSMike Smith 
4544975b7318SScott Long     mtx_lock(&sc->ciss_mtx);
45453a31b7ebSMike Smith     sc->ciss_flags &= ~CISS_FLAG_CONTROL_OPEN;
4546975b7318SScott Long     mtx_unlock(&sc->ciss_mtx);
45473a31b7ebSMike Smith     return (0);
45483a31b7ebSMike Smith }
45493a31b7ebSMike Smith 
45503a31b7ebSMike Smith /********************************************************************************
45513a31b7ebSMike Smith  * Handle adapter-specific control operations.
45523a31b7ebSMike Smith  *
45533a31b7ebSMike Smith  * Note that the API here is compatible with the Linux driver, in order to
45543a31b7ebSMike Smith  * simplify the porting of Compaq's userland tools.
45553a31b7ebSMike Smith  */
45563a31b7ebSMike Smith static int
455700b4e54aSWarner Losh ciss_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int32_t flag, struct thread *p)
45583a31b7ebSMike Smith {
45593a31b7ebSMike Smith     struct ciss_softc		*sc;
45607caeec6aSPaul Saab     IOCTL_Command_struct	*ioc	= (IOCTL_Command_struct *)addr;
45617caeec6aSPaul Saab #ifdef __amd64__
45627caeec6aSPaul Saab     IOCTL_Command_struct32	*ioc32	= (IOCTL_Command_struct32 *)addr;
45637caeec6aSPaul Saab     IOCTL_Command_struct	ioc_swab;
45647caeec6aSPaul Saab #endif
45653a31b7ebSMike Smith     int				error;
45663a31b7ebSMike Smith 
45673a31b7ebSMike Smith     debug_called(1);
45683a31b7ebSMike Smith 
45693a31b7ebSMike Smith     sc = (struct ciss_softc *)dev->si_drv1;
45703a31b7ebSMike Smith     error = 0;
4571975b7318SScott Long     mtx_lock(&sc->ciss_mtx);
45723a31b7ebSMike Smith 
45733a31b7ebSMike Smith     switch(cmd) {
457422657ce1SScott Long     case CCISS_GETQSTATS:
457522657ce1SScott Long     {
457622657ce1SScott Long 	union ciss_statrequest *cr = (union ciss_statrequest *)addr;
457722657ce1SScott Long 
457822657ce1SScott Long 	switch (cr->cs_item) {
457922657ce1SScott Long 	case CISSQ_FREE:
458022657ce1SScott Long 	case CISSQ_NOTIFY:
458122657ce1SScott Long 	    bcopy(&sc->ciss_qstat[cr->cs_item], &cr->cs_qstat,
458222657ce1SScott Long 		sizeof(struct ciss_qstat));
458322657ce1SScott Long 	    break;
458422657ce1SScott Long 	default:
458522657ce1SScott Long 	    error = ENOIOCTL;
458622657ce1SScott Long 	    break;
458722657ce1SScott Long 	}
458822657ce1SScott Long 
458922657ce1SScott Long 	break;
459022657ce1SScott Long     }
459122657ce1SScott Long 
45923a31b7ebSMike Smith     case CCISS_GETPCIINFO:
45933a31b7ebSMike Smith     {
45943a31b7ebSMike Smith 	cciss_pci_info_struct	*pis = (cciss_pci_info_struct *)addr;
45953a31b7ebSMike Smith 
45963a31b7ebSMike Smith 	pis->bus = pci_get_bus(sc->ciss_dev);
45973a31b7ebSMike Smith 	pis->dev_fn = pci_get_slot(sc->ciss_dev);
4598e17ef005SSean Bruno         pis->board_id = (pci_get_subvendor(sc->ciss_dev) << 16) |
4599e17ef005SSean Bruno                 pci_get_subdevice(sc->ciss_dev);
46003a31b7ebSMike Smith 
46013a31b7ebSMike Smith 	break;
46023a31b7ebSMike Smith     }
46033a31b7ebSMike Smith 
46043a31b7ebSMike Smith     case CCISS_GETINTINFO:
46053a31b7ebSMike Smith     {
46063a31b7ebSMike Smith 	cciss_coalint_struct	*cis = (cciss_coalint_struct *)addr;
46073a31b7ebSMike Smith 
46083a31b7ebSMike Smith 	cis->delay = sc->ciss_cfg->interrupt_coalesce_delay;
46093a31b7ebSMike Smith 	cis->count = sc->ciss_cfg->interrupt_coalesce_count;
46103a31b7ebSMike Smith 
46113a31b7ebSMike Smith 	break;
46123a31b7ebSMike Smith     }
46133a31b7ebSMike Smith 
46143a31b7ebSMike Smith     case CCISS_SETINTINFO:
46153a31b7ebSMike Smith     {
46163a31b7ebSMike Smith 	cciss_coalint_struct	*cis = (cciss_coalint_struct *)addr;
46173a31b7ebSMike Smith 
46183a31b7ebSMike Smith 	if ((cis->delay == 0) && (cis->count == 0)) {
46193a31b7ebSMike Smith 	    error = EINVAL;
46203a31b7ebSMike Smith 	    break;
46213a31b7ebSMike Smith 	}
46223a31b7ebSMike Smith 
46233a31b7ebSMike Smith 	/*
46243a31b7ebSMike Smith 	 * XXX apparently this is only safe if the controller is idle,
46253a31b7ebSMike Smith 	 *     we should suspend it before doing this.
46263a31b7ebSMike Smith 	 */
46273a31b7ebSMike Smith 	sc->ciss_cfg->interrupt_coalesce_delay = cis->delay;
46283a31b7ebSMike Smith 	sc->ciss_cfg->interrupt_coalesce_count = cis->count;
46293a31b7ebSMike Smith 
46303a31b7ebSMike Smith 	if (ciss_update_config(sc))
46313a31b7ebSMike Smith 	    error = EIO;
46323a31b7ebSMike Smith 
46333a31b7ebSMike Smith 	/* XXX resume the controller here */
46343a31b7ebSMike Smith 	break;
46353a31b7ebSMike Smith     }
46363a31b7ebSMike Smith 
46373a31b7ebSMike Smith     case CCISS_GETNODENAME:
46383a31b7ebSMike Smith 	bcopy(sc->ciss_cfg->server_name, (NodeName_type *)addr,
46393a31b7ebSMike Smith 	      sizeof(NodeName_type));
46403a31b7ebSMike Smith 	break;
46413a31b7ebSMike Smith 
46423a31b7ebSMike Smith     case CCISS_SETNODENAME:
46433a31b7ebSMike Smith 	bcopy((NodeName_type *)addr, sc->ciss_cfg->server_name,
46443a31b7ebSMike Smith 	      sizeof(NodeName_type));
46453a31b7ebSMike Smith 	if (ciss_update_config(sc))
46463a31b7ebSMike Smith 	    error = EIO;
46473a31b7ebSMike Smith 	break;
46483a31b7ebSMike Smith 
46493a31b7ebSMike Smith     case CCISS_GETHEARTBEAT:
46503a31b7ebSMike Smith 	*(Heartbeat_type *)addr = sc->ciss_cfg->heartbeat;
46513a31b7ebSMike Smith 	break;
46523a31b7ebSMike Smith 
46533a31b7ebSMike Smith     case CCISS_GETBUSTYPES:
46543a31b7ebSMike Smith 	*(BusTypes_type *)addr = sc->ciss_cfg->bus_types;
46553a31b7ebSMike Smith 	break;
46563a31b7ebSMike Smith 
46573a31b7ebSMike Smith     case CCISS_GETFIRMVER:
46583a31b7ebSMike Smith 	bcopy(sc->ciss_id->running_firmware_revision, (FirmwareVer_type *)addr,
46593a31b7ebSMike Smith 	      sizeof(FirmwareVer_type));
46603a31b7ebSMike Smith 	break;
46613a31b7ebSMike Smith 
46623a31b7ebSMike Smith     case CCISS_GETDRIVERVER:
46633a31b7ebSMike Smith 	*(DriverVer_type *)addr = CISS_DRIVER_VERSION;
46643a31b7ebSMike Smith 	break;
46653a31b7ebSMike Smith 
46663a31b7ebSMike Smith     case CCISS_REVALIDVOLS:
46673a31b7ebSMike Smith 	/*
46683a31b7ebSMike Smith 	 * This is a bit ugly; to do it "right" we really need
46693a31b7ebSMike Smith 	 * to find any disks that have changed, kick CAM off them,
46703a31b7ebSMike Smith 	 * then rescan only these disks.  It'd be nice if they
46713a31b7ebSMike Smith 	 * a) told us which disk(s) they were going to play with,
46723a31b7ebSMike Smith 	 * and b) which ones had arrived. 8(
46733a31b7ebSMike Smith 	 */
46743a31b7ebSMike Smith 	break;
46753a31b7ebSMike Smith 
46767caeec6aSPaul Saab #ifdef __amd64__
46777caeec6aSPaul Saab     case CCISS_PASSTHRU32:
46787caeec6aSPaul Saab 	ioc_swab.LUN_info	= ioc32->LUN_info;
46797caeec6aSPaul Saab 	ioc_swab.Request	= ioc32->Request;
46807caeec6aSPaul Saab 	ioc_swab.error_info	= ioc32->error_info;
46817caeec6aSPaul Saab 	ioc_swab.buf_size	= ioc32->buf_size;
46827caeec6aSPaul Saab 	ioc_swab.buf		= (u_int8_t *)(uintptr_t)ioc32->buf;
46837caeec6aSPaul Saab 	ioc			= &ioc_swab;
46847caeec6aSPaul Saab 	/* FALLTHROUGH */
46857caeec6aSPaul Saab #endif
46867caeec6aSPaul Saab 
46873a31b7ebSMike Smith     case CCISS_PASSTHRU:
46887caeec6aSPaul Saab 	error = ciss_user_command(sc, ioc);
46893a31b7ebSMike Smith 	break;
46903a31b7ebSMike Smith 
46913a31b7ebSMike Smith     default:
46923a31b7ebSMike Smith 	debug(0, "unknown ioctl 0x%lx", cmd);
46933a31b7ebSMike Smith 
46943a31b7ebSMike Smith 	debug(1, "CCISS_GETPCIINFO:   0x%lx", CCISS_GETPCIINFO);
46953a31b7ebSMike Smith 	debug(1, "CCISS_GETINTINFO:   0x%lx", CCISS_GETINTINFO);
46963a31b7ebSMike Smith 	debug(1, "CCISS_SETINTINFO:   0x%lx", CCISS_SETINTINFO);
46973a31b7ebSMike Smith 	debug(1, "CCISS_GETNODENAME:  0x%lx", CCISS_GETNODENAME);
46983a31b7ebSMike Smith 	debug(1, "CCISS_SETNODENAME:  0x%lx", CCISS_SETNODENAME);
46993a31b7ebSMike Smith 	debug(1, "CCISS_GETHEARTBEAT: 0x%lx", CCISS_GETHEARTBEAT);
47003a31b7ebSMike Smith 	debug(1, "CCISS_GETBUSTYPES:  0x%lx", CCISS_GETBUSTYPES);
47013a31b7ebSMike Smith 	debug(1, "CCISS_GETFIRMVER:   0x%lx", CCISS_GETFIRMVER);
47023a31b7ebSMike Smith 	debug(1, "CCISS_GETDRIVERVER: 0x%lx", CCISS_GETDRIVERVER);
47033a31b7ebSMike Smith 	debug(1, "CCISS_REVALIDVOLS:  0x%lx", CCISS_REVALIDVOLS);
47043a31b7ebSMike Smith 	debug(1, "CCISS_PASSTHRU:     0x%lx", CCISS_PASSTHRU);
47053a31b7ebSMike Smith 
47063a31b7ebSMike Smith 	error = ENOIOCTL;
47073a31b7ebSMike Smith 	break;
47083a31b7ebSMike Smith     }
47093a31b7ebSMike Smith 
4710975b7318SScott Long     mtx_unlock(&sc->ciss_mtx);
47113a31b7ebSMike Smith     return(error);
47123a31b7ebSMike Smith }
4713