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