9fac68fc38
It includes: 1)Newly added TMF feature. 2)Added newly Huawei & Inspur PCI ID's 3)Fixed smartpqi driver hangs in Z-Pool while running on FreeBSD12.1 4)Fixed flooding dmesg in kernel while the controller is offline during in ioctls. 5)Avoided unnecessary host memory allocation for rcb sg buffers. 6)Fixed race conditions while accessing internal rcb structure. 7)Fixed where Logical volumes exposing two different names to the OS it's due to the system memory is overwritten with DMA stale data. 8)Fixed dynamically unloading a smartpqi driver. 9)Added device_shutdown callback instead of deprecated shutdown_final kernel event in smartpqi driver. 10)Fixed where Os is crashed during physical drive hot removal during heavy IO. 11)Fixed OS crash during controller lockup/offline during heavy IO. 12)Fixed coverity issues in smartpqi driver 13)Fixed system crash while creating and deleting logical volume in a continuous loop. 14)Fixed where the volume size is not exposing to OS when it expands. 15)Added HC3 pci id's. Reviewed by: Scott Benesh (microsemi), Murthy Bhat (microsemi), imp Differential Revision: https://reviews.freebsd.org/D30182 Sponsored by: Netflix
566 lines
18 KiB
C
566 lines
18 KiB
C
/*-
|
|
* Copyright 2016-2021 Microchip Technology, Inc. and/or its subsidiaries.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
/* $FreeBSD$ */
|
|
|
|
/*
|
|
* Driver for the Microsemi Smart storage controllers
|
|
*/
|
|
|
|
#include "smartpqi_includes.h"
|
|
#include "smartpqi_prototypes.h"
|
|
|
|
CTASSERT(BSD_SUCCESS == PQI_STATUS_SUCCESS);
|
|
|
|
/*
|
|
* Supported devices
|
|
*/
|
|
struct pqi_ident
|
|
{
|
|
u_int16_t vendor;
|
|
u_int16_t device;
|
|
u_int16_t subvendor;
|
|
u_int16_t subdevice;
|
|
int hwif;
|
|
char *desc;
|
|
} pqi_identifiers[] = {
|
|
/* (MSCC PM8205 8x12G based) */
|
|
{0x9005, 0x028f, 0x103c, 0x600, PQI_HWIF_SRCV, "P408i-p SR Gen10"},
|
|
{0x9005, 0x028f, 0x103c, 0x601, PQI_HWIF_SRCV, "P408e-p SR Gen10"},
|
|
{0x9005, 0x028f, 0x103c, 0x602, PQI_HWIF_SRCV, "P408i-a SR Gen10"},
|
|
{0x9005, 0x028f, 0x103c, 0x603, PQI_HWIF_SRCV, "P408i-c SR Gen10"},
|
|
{0x9005, 0x028f, 0x1028, 0x1FE0, PQI_HWIF_SRCV, "SmartRAID 3162-8i/eDell"},
|
|
{0x9005, 0x028f, 0x9005, 0x608, PQI_HWIF_SRCV, "SmartRAID 3162-8i/e"},
|
|
{0x9005, 0x028f, 0x103c, 0x609, PQI_HWIF_SRCV, "P408i-sb SR G10"},
|
|
|
|
/* (MSCC PM8225 8x12G based) */
|
|
{0x9005, 0x028f, 0x103c, 0x650, PQI_HWIF_SRCV, "E208i-p SR Gen10"},
|
|
{0x9005, 0x028f, 0x103c, 0x651, PQI_HWIF_SRCV, "E208e-p SR Gen10"},
|
|
{0x9005, 0x028f, 0x103c, 0x652, PQI_HWIF_SRCV, "E208i-c SR Gen10"},
|
|
{0x9005, 0x028f, 0x103c, 0x654, PQI_HWIF_SRCV, "E208i-a SR Gen10"},
|
|
{0x9005, 0x028f, 0x103c, 0x655, PQI_HWIF_SRCV, "P408e-m SR Gen10"},
|
|
|
|
/* (MSCC PM8221 8x12G based) */
|
|
{0x9005, 0x028f, 0x103c, 0x700, PQI_HWIF_SRCV, "P204i-c SR Gen10"},
|
|
{0x9005, 0x028f, 0x103c, 0x701, PQI_HWIF_SRCV, "P204i-b SR Gen10"},
|
|
{0x9005, 0x028f, 0x193d, 0x1104, PQI_HWIF_SRCV, "UN RAID P2404-Mf-4i-2GB"},
|
|
{0x9005, 0x028f, 0x193d, 0x1106, PQI_HWIF_SRCV, "UN RAID P2404-Mf-4i-1GB"},
|
|
{0x9005, 0x028f, 0x193d, 0x1108, PQI_HWIF_SRCV, "UN RAID P4408-Ma-8i-2GB"},
|
|
|
|
|
|
/* (MSCC PM8204 8x12G based) */
|
|
{0x9005, 0x028f, 0x9005, 0x800, PQI_HWIF_SRCV, "SmartRAID 3154-8i"},
|
|
{0x9005, 0x028f, 0x9005, 0x801, PQI_HWIF_SRCV, "SmartRAID 3152-8i"},
|
|
{0x9005, 0x028f, 0x9005, 0x802, PQI_HWIF_SRCV, "SmartRAID 3151-4i"},
|
|
{0x9005, 0x028f, 0x9005, 0x803, PQI_HWIF_SRCV, "SmartRAID 3101-4i"},
|
|
{0x9005, 0x028f, 0x9005, 0x804, PQI_HWIF_SRCV, "SmartRAID 3154-8e"},
|
|
{0x9005, 0x028f, 0x9005, 0x805, PQI_HWIF_SRCV, "SmartRAID 3102-8i"},
|
|
{0x9005, 0x028f, 0x9005, 0x806, PQI_HWIF_SRCV, "SmartRAID 3100"},
|
|
{0x9005, 0x028f, 0x9005, 0x807, PQI_HWIF_SRCV, "SmartRAID 3162-8i"},
|
|
{0x9005, 0x028f, 0x152d, 0x8a22, PQI_HWIF_SRCV, "QS-8204-8i"},
|
|
{0x9005, 0x028f, 0x193d, 0xf460, PQI_HWIF_SRCV, "UN RAID P460-M4"},
|
|
{0x9005, 0x028f, 0x193d, 0xf461, PQI_HWIF_SRCV, "UN RAID P460-B4"},
|
|
{0x9005, 0x028f, 0x1bd4, 0x004b, PQI_HWIF_SRCV, "INSPUR PM8204-2GB"},
|
|
{0x9005, 0x028f, 0x1bd4, 0x004c, PQI_HWIF_SRCV, "INSPUR PM8204-4GB"},
|
|
{0x9005, 0x028f, 0x193d, 0x1105, PQI_HWIF_SRCV, "UN RAID P4408-Mf-8i-2GB"},
|
|
{0x9005, 0x028f, 0x193d, 0x1107, PQI_HWIF_SRCV, "UN RAID P4408-Mf-8i-4GB"},
|
|
{0x9005, 0x028f, 0x1d8d, 0x800, PQI_HWIF_SRCV, "Fiberhome SmartRAID AIS-8204-8i"},
|
|
{0x9005, 0x028f, 0x9005, 0x0808, PQI_HWIF_SRCV, "SmartRAID 3101E-4i"},
|
|
{0x9005, 0x028f, 0x9005, 0x0809, PQI_HWIF_SRCV, "SmartRAID 3102E-8i"},
|
|
{0x9005, 0x028f, 0x9005, 0x080a, PQI_HWIF_SRCV, "SmartRAID 3152-8i/N"},
|
|
|
|
/* (MSCC PM8222 8x12G based) */
|
|
{0x9005, 0x028f, 0x9005, 0x900, PQI_HWIF_SRCV, "SmartHBA 2100-8i"},
|
|
{0x9005, 0x028f, 0x9005, 0x901, PQI_HWIF_SRCV, "SmartHBA 2100-4i"},
|
|
{0x9005, 0x028f, 0x9005, 0x902, PQI_HWIF_SRCV, "HBA 1100-8i"},
|
|
{0x9005, 0x028f, 0x9005, 0x903, PQI_HWIF_SRCV, "HBA 1100-4i"},
|
|
{0x9005, 0x028f, 0x9005, 0x904, PQI_HWIF_SRCV, "SmartHBA 2100-8e"},
|
|
{0x9005, 0x028f, 0x9005, 0x905, PQI_HWIF_SRCV, "HBA 1100-8e"},
|
|
{0x9005, 0x028f, 0x9005, 0x906, PQI_HWIF_SRCV, "SmartHBA 2100-4i4e"},
|
|
{0x9005, 0x028f, 0x9005, 0x907, PQI_HWIF_SRCV, "HBA 1100"},
|
|
{0x9005, 0x028f, 0x9005, 0x908, PQI_HWIF_SRCV, "SmartHBA 2100"},
|
|
{0x9005, 0x028f, 0x9005, 0x90a, PQI_HWIF_SRCV, "SmartHBA 2100A-8i"},
|
|
{0x9005, 0x028f, 0x193d, 0x8460, PQI_HWIF_SRCV, "UN HBA H460-M1"},
|
|
{0x9005, 0x028f, 0x193d, 0x8461, PQI_HWIF_SRCV, "UN HBA H460-B1"},
|
|
{0x9005, 0x028f, 0x193d, 0xc460, PQI_HWIF_SRCV, "UN RAID P460-M2"},
|
|
{0x9005, 0x028f, 0x193d, 0xc461, PQI_HWIF_SRCV, "UN RAID P460-B2"},
|
|
{0x9005, 0x028f, 0x1bd4, 0x004a, PQI_HWIF_SRCV, "INSPUR PM8222-SHBA"},
|
|
{0x9005, 0x028f, 0x13fe, 0x8312, PQI_HWIF_SRCV, "MIC-8312BridgeB"},
|
|
{0x9005, 0x028f, 0x1bd4, 0x004f, PQI_HWIF_SRCV, "INSPUR PM8222-HBA"},
|
|
{0x9005, 0x028f, 0x1d8d, 0x908, PQI_HWIF_SRCV, "Fiberhome SmartHBA AIS-8222-8i"},
|
|
|
|
/* (SRCx MSCC FVB 24x12G based) */
|
|
{0x9005, 0x028f, 0x103c, 0x1001, PQI_HWIF_SRCV, "MSCC FVB"},
|
|
|
|
/* (MSCC PM8241 24x12G based) */
|
|
|
|
/* (MSCC PM8242 24x12G based) */
|
|
{0x9005, 0x028f, 0x152d, 0x8a37, PQI_HWIF_SRCV, "QS-8242-24i"},
|
|
{0x9005, 0x028f, 0x9005, 0x1300, PQI_HWIF_SRCV, "HBA 1100-8i8e"},
|
|
{0x9005, 0x028f, 0x9005, 0x1301, PQI_HWIF_SRCV, "HBA 1100-24i"},
|
|
{0x9005, 0x028f, 0x9005, 0x1302, PQI_HWIF_SRCV, "SmartHBA 2100-8i8e"},
|
|
{0x9005, 0x028f, 0x9005, 0x1303, PQI_HWIF_SRCV, "SmartHBA 2100-24i"},
|
|
{0x9005, 0x028f, 0x105b, 0x1321, PQI_HWIF_SRCV, "8242-24i"},
|
|
{0x9005, 0x028f, 0x1bd4, 0x0045, PQI_HWIF_SRCV, "INSPUR SMART-HBA 8242-24i"},
|
|
|
|
/* (MSCC PM8236 16x12G based) */
|
|
{0x9005, 0x028f, 0x152d, 0x8a24, PQI_HWIF_SRCV, "QS-8236-16i"},
|
|
{0x9005, 0x028f, 0x9005, 0x1380, PQI_HWIF_SRCV, "SmartRAID 3154-16i"},
|
|
{0x9005, 0x028f, 0x1bd4, 0x0046, PQI_HWIF_SRCV, "INSPUR RAID 8236-16i"},
|
|
{0x9005, 0x028f, 0x1d8d, 0x806, PQI_HWIF_SRCV, "Fiberhome SmartRAID AIS-8236-16i"},
|
|
|
|
/* (MSCC PM8237 24x12G based) */
|
|
{0x9005, 0x028f, 0x103c, 0x1100, PQI_HWIF_SRCV, "P816i-a SR Gen10"},
|
|
{0x9005, 0x028f, 0x103c, 0x1101, PQI_HWIF_SRCV, "P416ie-m SR G10"},
|
|
|
|
/* (MSCC PM8238 16x12G based) */
|
|
{0x9005, 0x028f, 0x152d, 0x8a23, PQI_HWIF_SRCV, "QS-8238-16i"},
|
|
{0x9005, 0x028f, 0x9005, 0x1280, PQI_HWIF_SRCV, "HBA 1100-16i"},
|
|
{0x9005, 0x028f, 0x9005, 0x1281, PQI_HWIF_SRCV, "HBA 1100-16e"},
|
|
{0x9005, 0x028f, 0x105b, 0x1211, PQI_HWIF_SRCV, "8238-16i"},
|
|
{0x9005, 0x028f, 0x1bd4, 0x0048, PQI_HWIF_SRCV, "INSPUR SMART-HBA 8238-16i"},
|
|
{0x9005, 0x028f, 0x9005, 0x1282, PQI_HWIF_SRCV, "SmartHBA 2100-16i"},
|
|
{0x9005, 0x028f, 0x1d8d, 0x916, PQI_HWIF_SRCV, "Fiberhome SmartHBA AIS-8238-16i"},
|
|
{0x9005, 0x028f, 0x1458, 0x1000, PQI_HWIF_SRCV, "GIGABYTE SmartHBA CLN1832"},
|
|
|
|
/* (MSCC PM8240 24x12G based) */
|
|
{0x9005, 0x028f, 0x152d, 0x8a36, PQI_HWIF_SRCV, "QS-8240-24i"},
|
|
{0x9005, 0x028f, 0x9005, 0x1200, PQI_HWIF_SRCV, "SmartRAID 3154-24i"},
|
|
{0x9005, 0x028f, 0x9005, 0x1201, PQI_HWIF_SRCV, "SmartRAID 3154-8i16e"},
|
|
{0x9005, 0x028f, 0x9005, 0x1202, PQI_HWIF_SRCV, "SmartRAID 3154-8i8e"},
|
|
{0x9005, 0x028f, 0x1bd4, 0x0047, PQI_HWIF_SRCV, "INSPUR RAID 8240-24i"},
|
|
|
|
/* Huawei ID's */
|
|
{0x9005, 0x028f, 0x19e5, 0xd227, PQI_HWIF_SRCV, "SR465C-M 4G"},
|
|
{0x9005, 0x028f, 0x19e5, 0xd22a, PQI_HWIF_SRCV, "SR765-M"},
|
|
{0x9005, 0x028f, 0x19e5, 0xd228, PQI_HWIF_SRCV, "SR455C-M 2G"},
|
|
{0x9005, 0x028f, 0x19e5, 0xd22c, PQI_HWIF_SRCV, "SR455C-M 4G"},
|
|
{0x9005, 0x028f, 0x19e5, 0xd229, PQI_HWIF_SRCV, "SR155-M"},
|
|
{0x9005, 0x028f, 0x19e5, 0xd22b, PQI_HWIF_SRCV, "SR455C-ME 4G"},
|
|
|
|
{0, 0, 0, 0, 0, 0}
|
|
};
|
|
|
|
struct pqi_ident
|
|
pqi_family_identifiers[] = {
|
|
{0x9005, 0x028f, 0, 0, PQI_HWIF_SRCV, "Smart Array Storage Controller"},
|
|
{0, 0, 0, 0, 0, 0}
|
|
};
|
|
|
|
/*
|
|
* Function to identify the installed adapter.
|
|
*/
|
|
static struct
|
|
pqi_ident *pqi_find_ident(device_t dev)
|
|
{
|
|
struct pqi_ident *m;
|
|
u_int16_t vendid, devid, sub_vendid, sub_devid;
|
|
|
|
vendid = pci_get_vendor(dev);
|
|
devid = pci_get_device(dev);
|
|
sub_vendid = pci_get_subvendor(dev);
|
|
sub_devid = pci_get_subdevice(dev);
|
|
|
|
for (m = pqi_identifiers; m->vendor != 0; m++) {
|
|
if ((m->vendor == vendid) && (m->device == devid) &&
|
|
(m->subvendor == sub_vendid) &&
|
|
(m->subdevice == sub_devid)) {
|
|
return (m);
|
|
}
|
|
}
|
|
|
|
for (m = pqi_family_identifiers; m->vendor != 0; m++) {
|
|
if ((m->vendor == vendid) && (m->device == devid)) {
|
|
return (m);
|
|
}
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
/*
|
|
* Determine whether this is one of our supported adapters.
|
|
*/
|
|
static int
|
|
smartpqi_probe(device_t dev)
|
|
{
|
|
struct pqi_ident *id;
|
|
|
|
if ((id = pqi_find_ident(dev)) != NULL) {
|
|
device_set_desc(dev, id->desc);
|
|
return(BUS_PROBE_VENDOR);
|
|
}
|
|
|
|
return(ENXIO);
|
|
}
|
|
|
|
/*
|
|
* Store Bus/Device/Function in softs
|
|
*/
|
|
void
|
|
pqisrc_save_controller_info(struct pqisrc_softstate *softs)
|
|
{
|
|
device_t dev = softs->os_specific.pqi_dev;
|
|
|
|
softs->bus_id = (uint32_t)pci_get_bus(dev);
|
|
softs->device_id = (uint32_t)pci_get_device(dev);
|
|
softs->func_id = (uint32_t)pci_get_function(dev);
|
|
}
|
|
|
|
|
|
/*
|
|
* Allocate resources for our device, set up the bus interface.
|
|
* Initialize the PQI related functionality, scan devices, register sim to
|
|
* upper layer, create management interface device node etc.
|
|
*/
|
|
static int
|
|
smartpqi_attach(device_t dev)
|
|
{
|
|
struct pqisrc_softstate *softs = NULL;
|
|
struct pqi_ident *id = NULL;
|
|
int error = BSD_SUCCESS;
|
|
u_int32_t command = 0, i = 0;
|
|
int card_index = device_get_unit(dev);
|
|
rcb_t *rcbp = NULL;
|
|
|
|
/*
|
|
* Initialise softc.
|
|
*/
|
|
softs = device_get_softc(dev);
|
|
|
|
if (!softs) {
|
|
printf("Could not get softc\n");
|
|
error = EINVAL;
|
|
goto out;
|
|
}
|
|
memset(softs, 0, sizeof(*softs));
|
|
softs->os_specific.pqi_dev = dev;
|
|
|
|
DBG_FUNC("IN\n");
|
|
|
|
/* assume failure is 'not configured' */
|
|
error = ENXIO;
|
|
|
|
/*
|
|
* Verify that the adapter is correctly set up in PCI space.
|
|
*/
|
|
pci_enable_busmaster(softs->os_specific.pqi_dev);
|
|
command = pci_read_config(softs->os_specific.pqi_dev, PCIR_COMMAND, 2);
|
|
if ((command & PCIM_CMD_MEMEN) == 0) {
|
|
DBG_ERR("memory window not available command = %d\n", command);
|
|
error = ENXIO;
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* Detect the hardware interface version, set up the bus interface
|
|
* indirection.
|
|
*/
|
|
id = pqi_find_ident(dev);
|
|
if (!id) {
|
|
DBG_ERR("NULL return value from pqi_find_ident\n");
|
|
goto out;
|
|
}
|
|
|
|
softs->os_specific.pqi_hwif = id->hwif;
|
|
|
|
switch(softs->os_specific.pqi_hwif) {
|
|
case PQI_HWIF_SRCV:
|
|
DBG_INFO("set hardware up for PMC SRCv for %p\n", softs);
|
|
break;
|
|
default:
|
|
softs->os_specific.pqi_hwif = PQI_HWIF_UNKNOWN;
|
|
DBG_ERR("unknown hardware type\n");
|
|
error = ENXIO;
|
|
goto out;
|
|
}
|
|
|
|
pqisrc_save_controller_info(softs);
|
|
|
|
/*
|
|
* Allocate the PCI register window.
|
|
*/
|
|
softs->os_specific.pqi_regs_rid0 = PCIR_BAR(0);
|
|
if ((softs->os_specific.pqi_regs_res0 =
|
|
bus_alloc_resource_any(softs->os_specific.pqi_dev, SYS_RES_MEMORY,
|
|
&softs->os_specific.pqi_regs_rid0, RF_ACTIVE)) == NULL) {
|
|
DBG_ERR("couldn't allocate register window 0\n");
|
|
/* assume failure is 'out of memory' */
|
|
error = ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
bus_get_resource_start(softs->os_specific.pqi_dev, SYS_RES_MEMORY,
|
|
softs->os_specific.pqi_regs_rid0);
|
|
|
|
softs->pci_mem_handle.pqi_btag = rman_get_bustag(softs->os_specific.pqi_regs_res0);
|
|
softs->pci_mem_handle.pqi_bhandle = rman_get_bushandle(softs->os_specific.pqi_regs_res0);
|
|
/* softs->pci_mem_base_vaddr = (uintptr_t)rman_get_virtual(softs->os_specific.pqi_regs_res0); */
|
|
softs->pci_mem_base_vaddr = (char *)rman_get_virtual(softs->os_specific.pqi_regs_res0);
|
|
|
|
/*
|
|
* Allocate the parent bus DMA tag appropriate for our PCI interface.
|
|
*
|
|
* Note that some of these controllers are 64-bit capable.
|
|
*/
|
|
if (bus_dma_tag_create(bus_get_dma_tag(dev), /* parent */
|
|
PAGE_SIZE, 0, /* algnmnt, boundary */
|
|
BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
|
|
BUS_SPACE_MAXADDR, /* highaddr */
|
|
NULL, NULL, /* filter, filterarg */
|
|
BUS_SPACE_MAXSIZE_32BIT, /* maxsize */
|
|
BUS_SPACE_UNRESTRICTED, /* nsegments */
|
|
BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
|
|
0, /* flags */
|
|
NULL, NULL, /* No locking needed */
|
|
&softs->os_specific.pqi_parent_dmat)) {
|
|
DBG_ERR("can't allocate parent DMA tag\n");
|
|
/* assume failure is 'out of memory' */
|
|
error = ENOMEM;
|
|
goto dma_out;
|
|
}
|
|
|
|
softs->os_specific.sim_registered = FALSE;
|
|
softs->os_name = "FreeBSD ";
|
|
|
|
/* Initialize the PQI library */
|
|
error = pqisrc_init(softs);
|
|
if (error != PQI_STATUS_SUCCESS) {
|
|
DBG_ERR("Failed to initialize pqi lib error = %d\n", error);
|
|
error = ENXIO;
|
|
goto out;
|
|
}
|
|
else {
|
|
error = BSD_SUCCESS;
|
|
}
|
|
|
|
mtx_init(&softs->os_specific.cam_lock, "cam_lock", NULL, MTX_DEF);
|
|
softs->os_specific.mtx_init = TRUE;
|
|
mtx_init(&softs->os_specific.map_lock, "map_lock", NULL, MTX_DEF);
|
|
|
|
callout_init(&softs->os_specific.wellness_periodic, 1);
|
|
callout_init(&softs->os_specific.heartbeat_timeout_id, 1);
|
|
|
|
/*
|
|
* Create DMA tag for mapping buffers into controller-addressable space.
|
|
*/
|
|
if (bus_dma_tag_create(softs->os_specific.pqi_parent_dmat,/* parent */
|
|
PAGE_SIZE, 0, /* algnmnt, boundary */
|
|
BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
|
|
BUS_SPACE_MAXADDR, /* highaddr */
|
|
NULL, NULL, /* filter, filterarg */
|
|
(bus_size_t)softs->pqi_cap.max_sg_elem*PAGE_SIZE,/* maxsize */
|
|
softs->pqi_cap.max_sg_elem, /* nsegments */
|
|
BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
|
|
BUS_DMA_ALLOCNOW, /* flags */
|
|
busdma_lock_mutex, /* lockfunc */
|
|
&softs->os_specific.map_lock, /* lockfuncarg*/
|
|
&softs->os_specific.pqi_buffer_dmat)) {
|
|
DBG_ERR("can't allocate buffer DMA tag for pqi_buffer_dmat\n");
|
|
return (ENOMEM);
|
|
}
|
|
|
|
rcbp = &softs->rcb[1];
|
|
for( i = 1; i <= softs->pqi_cap.max_outstanding_io; i++, rcbp++ ) {
|
|
if ((error = bus_dmamap_create(softs->os_specific.pqi_buffer_dmat, 0, &rcbp->cm_datamap)) != 0) {
|
|
DBG_ERR("Cant create datamap for buf @"
|
|
"rcbp = %p maxio = %d error = %d\n",
|
|
rcbp, softs->pqi_cap.max_outstanding_io, error);
|
|
goto dma_out;
|
|
}
|
|
}
|
|
|
|
os_start_heartbeat_timer((void *)softs); /* Start the heart-beat timer */
|
|
callout_reset(&softs->os_specific.wellness_periodic, 120 * hz,
|
|
os_wellness_periodic, softs);
|
|
|
|
error = pqisrc_scan_devices(softs);
|
|
if (error != PQI_STATUS_SUCCESS) {
|
|
DBG_ERR("Failed to scan lib error = %d\n", error);
|
|
error = ENXIO;
|
|
goto out;
|
|
}
|
|
|
|
error = register_sim(softs, card_index);
|
|
if (error) {
|
|
DBG_ERR("Failed to register sim index = %d error = %d\n",
|
|
card_index, error);
|
|
goto out;
|
|
}
|
|
|
|
smartpqi_target_rescan(softs);
|
|
|
|
TASK_INIT(&softs->os_specific.event_task, 0, pqisrc_event_worker,softs);
|
|
|
|
error = create_char_dev(softs, card_index);
|
|
if (error) {
|
|
DBG_ERR("Failed to register character device index=%d r=%d\n",
|
|
card_index, error);
|
|
goto out;
|
|
}
|
|
goto out;
|
|
|
|
dma_out:
|
|
if (softs->os_specific.pqi_regs_res0 != NULL)
|
|
bus_release_resource(softs->os_specific.pqi_dev, SYS_RES_MEMORY,
|
|
softs->os_specific.pqi_regs_rid0,
|
|
softs->os_specific.pqi_regs_res0);
|
|
out:
|
|
DBG_FUNC("OUT error = %d\n", error);
|
|
return(error);
|
|
}
|
|
|
|
/*
|
|
* Deallocate resources for our device.
|
|
*/
|
|
static int
|
|
smartpqi_detach(device_t dev)
|
|
{
|
|
struct pqisrc_softstate *softs = device_get_softc(dev);
|
|
int rval = BSD_SUCCESS;
|
|
|
|
DBG_FUNC("IN\n");
|
|
|
|
if (softs == NULL)
|
|
return ENXIO;
|
|
|
|
/* kill the periodic event */
|
|
callout_drain(&softs->os_specific.wellness_periodic);
|
|
/* Kill the heart beat event */
|
|
callout_drain(&softs->os_specific.heartbeat_timeout_id);
|
|
|
|
if (!pqisrc_ctrl_offline(softs)) {
|
|
rval = pqisrc_flush_cache(softs, PQISRC_NONE_CACHE_FLUSH_ONLY);
|
|
if (rval != PQI_STATUS_SUCCESS) {
|
|
DBG_ERR("Unable to flush adapter cache! rval = %d\n", rval);
|
|
rval = EIO;
|
|
}
|
|
}
|
|
|
|
destroy_char_dev(softs);
|
|
pqisrc_uninit(softs);
|
|
deregister_sim(softs);
|
|
pci_release_msi(dev);
|
|
|
|
DBG_FUNC("OUT\n");
|
|
|
|
return rval;
|
|
}
|
|
|
|
/*
|
|
* Bring the controller to a quiescent state, ready for system suspend.
|
|
*/
|
|
static int
|
|
smartpqi_suspend(device_t dev)
|
|
{
|
|
struct pqisrc_softstate *softs = device_get_softc(dev);
|
|
|
|
DBG_FUNC("IN\n");
|
|
|
|
if (softs == NULL)
|
|
return ENXIO;
|
|
|
|
DBG_INFO("Suspending the device %p\n", softs);
|
|
softs->os_specific.pqi_state |= SMART_STATE_SUSPEND;
|
|
|
|
DBG_FUNC("OUT\n");
|
|
|
|
return BSD_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* Bring the controller back to a state ready for operation.
|
|
*/
|
|
static int
|
|
smartpqi_resume(device_t dev)
|
|
{
|
|
struct pqisrc_softstate *softs = device_get_softc(dev);
|
|
|
|
DBG_FUNC("IN\n");
|
|
|
|
if (softs == NULL)
|
|
return ENXIO;
|
|
|
|
softs->os_specific.pqi_state &= ~SMART_STATE_SUSPEND;
|
|
|
|
DBG_FUNC("OUT\n");
|
|
|
|
return BSD_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* Do whatever is needed during a system shutdown.
|
|
*/
|
|
static int
|
|
smartpqi_shutdown(device_t dev)
|
|
{
|
|
struct pqisrc_softstate *softs = device_get_softc(dev);
|
|
int bsd_status = BSD_SUCCESS;
|
|
int pqi_status;
|
|
|
|
DBG_FUNC("IN\n");
|
|
|
|
if (softs == NULL)
|
|
return ENXIO;
|
|
|
|
if (pqisrc_ctrl_offline(softs))
|
|
return BSD_SUCCESS;
|
|
|
|
pqi_status = pqisrc_flush_cache(softs, PQISRC_SHUTDOWN);
|
|
if (pqi_status != PQI_STATUS_SUCCESS) {
|
|
DBG_ERR("Unable to flush adapter cache! rval = %d\n", pqi_status);
|
|
bsd_status = EIO;
|
|
}
|
|
|
|
DBG_FUNC("OUT\n");
|
|
|
|
return bsd_status;
|
|
}
|
|
|
|
/*
|
|
* PCI bus interface.
|
|
*/
|
|
static device_method_t pqi_methods[] = {
|
|
/* Device interface */
|
|
DEVMETHOD(device_probe, smartpqi_probe),
|
|
DEVMETHOD(device_attach, smartpqi_attach),
|
|
DEVMETHOD(device_detach, smartpqi_detach),
|
|
DEVMETHOD(device_suspend, smartpqi_suspend),
|
|
DEVMETHOD(device_resume, smartpqi_resume),
|
|
DEVMETHOD(device_shutdown, smartpqi_shutdown),
|
|
{ 0, 0 }
|
|
};
|
|
|
|
static devclass_t pqi_devclass;
|
|
|
|
static driver_t smartpqi_pci_driver = {
|
|
"smartpqi",
|
|
pqi_methods,
|
|
sizeof(struct pqisrc_softstate)
|
|
};
|
|
|
|
DRIVER_MODULE(smartpqi, pci, smartpqi_pci_driver, pqi_devclass, 0, 0);
|
|
MODULE_DEPEND(smartpqi, pci, 1, 1, 1);
|