/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. */ #ifndef _SYS_IB_ADAPTERS_HERMON_H #define _SYS_IB_ADAPTERS_HERMON_H /* * hermon.h * Contains the #defines and typedefs necessary for the Hermon softstate * structure and for proper attach() and detach() processing. Also * includes all the other Hermon header files (and so is the only header * file that is directly included by the Hermon source files). * Lastly, this file includes everything necessary for implementing the * devmap interface and for maintaining the "mapped resource database". */ #include <sys/types.h> #include <sys/conf.h> #include <sys/ddi.h> #include <sys/sunddi.h> #include <sys/taskq.h> #include <sys/atomic.h> #ifdef FMA_TEST #include <sys/modhash.h> #endif #include <sys/ib/ibtl/ibci.h> #include <sys/ib/ibtl/impl/ibtl_util.h> #include <sys/ib/adapters/mlnx_umap.h> /* * First include all the Hermon typedefs, then include all the other Hermon * specific headers (many of which depend on the typedefs having already * been defined). */ #include <sys/ib/adapters/hermon/hermon_typedef.h> #include <sys/ib/adapters/hermon/hermon_hw.h> #include <sys/ib/adapters/hermon/hermon_agents.h> #include <sys/ib/adapters/hermon/hermon_cfg.h> #include <sys/ib/adapters/hermon/hermon_cmd.h> #include <sys/ib/adapters/hermon/hermon_cq.h> #include <sys/ib/adapters/hermon/hermon_event.h> #include <sys/ib/adapters/hermon/hermon_fcoib.h> #include <sys/ib/adapters/hermon/hermon_ioctl.h> #include <sys/ib/adapters/hermon/hermon_misc.h> #include <sys/ib/adapters/hermon/hermon_mr.h> #include <sys/ib/adapters/hermon/hermon_wr.h> #include <sys/ib/adapters/hermon/hermon_qp.h> #include <sys/ib/adapters/hermon/hermon_srq.h> #include <sys/ib/adapters/hermon/hermon_rsrc.h> #include <sys/ib/adapters/hermon/hermon_fm.h> #ifdef __cplusplus extern "C" { #endif /* * Number of initial states to setup. Used in call to ddi_soft_state_init() */ #define HERMON_INITIAL_STATES 3 /* * Macro and defines used to calculate device instance number from minor * number (and vice versa). */ #define HERMON_MINORNUM_SHIFT 3 #define HERMON_DEV_INSTANCE(dev) (getminor((dev)) & \ ((1 << HERMON_MINORNUM_SHIFT) - 1)) /* * Locations for the various Hermon hardware CMD,UAR & MSIx PCIe BARs */ #define HERMON_CMD_BAR 1 /* device config space */ #define HERMON_UAR_BAR 2 /* UAR Region */ #define HERMON_MSIX_BAR 3 /* MSI-X Table */ #define HERMON_ONCLOSE_FLASH_INPROGRESS (1 << 0) #define HERMON_MSIX_MAX 256 /* max # of interrupt vectors */ /* * VPD header size - or more rightfully, the area of interest for fwflash * There's more, but we don't need it for our use so we don't read it */ #define HERMON_VPD_HDR_DWSIZE 0x10 /* 16 Dwords */ #define HERMON_VPD_HDR_BSIZE 0x40 /* 64 Bytes */ /* * Offsets to be used w/ reset to save/restore PCI capability stuff */ #define HERMON_PCI_CAP_DEV_OFFS 0x08 #define HERMON_PCI_CAP_LNK_OFFS 0x10 /* * Some defines for the software reset. These define the value that should * be written to begin the reset (HERMON_SW_RESET_START), the delay before * beginning to poll for completion (HERMON_SW_RESET_DELAY), the in-between * polling delay (HERMON_SW_RESET_POLL_DELAY), and the value that indicates * that the reset has not completed (HERMON_SW_RESET_NOTDONE). */ #define HERMON_SW_RESET_START 0x00000001 #define HERMON_SW_RESET_DELAY 1000000 /* 1000 ms, per 0.36 PRM */ #define HERMON_SW_RESET_POLL_DELAY 100 /* 100 us */ #define HERMON_SW_RESET_NOTDONE 0xFFFFFFFF /* * These defines are used in the Hermon software reset operation. They define * the total number PCI registers to read/restore during the reset. And they * also specify two config registers which should not be read or restored. */ #define HERMON_SW_RESET_NUMREGS 0x40 #define HERMON_SW_RESET_REG22_RSVD 0x16 /* 22 dec */ #define HERMON_SW_RESET_REG23_RSVD 0x17 /* 23 dec */ /* * Macro used to output HCA warning messages. Note: HCA warning messages * are only generated when an unexpected condition has been detected. This * can be the result of a software bug or some other problem. Previously * this was used for hardware errors, but those now use HERMON_FMANOTE * instead, indicating that the driver state is more likely in an * unpredictable state, and that shutdown/restart is suggested. * * HERMON_WARNING messages are not considered important enough to print * to the console, just to the message log. */ #define HERMON_WARNING(state, string) \ cmn_err(CE_CONT, "!hermon%d: %s\n", (state)->hs_instance, string) /* * Macro used to set attach failure messages. Also, the attach message buf * size is set here. */ #define HERMON_ATTACH_MSGSIZE 80 #define HERMON_ATTACH_MSG(attach_buf, attach_msg) \ (void) snprintf((attach_buf), HERMON_ATTACH_MSGSIZE, (attach_msg)); #define HERMON_ATTACH_MSG_INIT(attach_buf) \ (attach_buf)[0] = '\0'; /* * Macros used for controlling whether or not event callbacks will be forwarded * to the IBTF. This is necessary because there are certain race conditions * that can occur (e.g. calling IBTF with an asynch event before the IBTF * registration has successfully completed or handling an event after we've * detached from the IBTF.) * * HERMON_ENABLE_IBTF_CALLB() initializes the "hs_ibtfpriv" field in the Hermon * softstate. When "hs_ibtfpriv" is non-NULL, it is OK to forward asynch * and CQ events to the IBTF. * * HERMON_DO_IBTF_ASYNC_CALLB() and HERMON_DO_IBTF_CQ_CALLB() both set and clear * the "hs_in_evcallb" flag, as necessary, to indicate that an IBTF * callback is currently in progress. This is necessary so that we can * block on this condition in hermon_detach(). * * HERMON_QUIESCE_IBTF_CALLB() is used in hermon_detach() to set the * "hs_ibtfpriv" to NULL (thereby disabling any further IBTF callbacks) * and to poll on the "hs_in_evcallb" flag. When this flag is zero, all * IBTF callbacks have quiesced and it is safe to continue with detach * (i.e. continue detaching from IBTF). */ #define HERMON_ENABLE_IBTF_CALLB(state, tmp_ibtfpriv) \ (state)->hs_ibtfpriv = (tmp_ibtfpriv); #define HERMON_DO_IBTF_ASYNC_CALLB(state, type, event) \ _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS((state)->hs_in_evcallb)) \ (state)->hs_in_evcallb = 1; \ ibc_async_handler((state)->hs_ibtfpriv, (type), (event)); \ (state)->hs_in_evcallb = 0; #define HERMON_DO_IBTF_CQ_CALLB(state, cq) \ _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS((state)->hs_in_evcallb)) \ (state)->hs_in_evcallb = 1; \ ibc_cq_handler((state)->hs_ibtfpriv, (cq)->cq_hdlrarg); \ (state)->hs_in_evcallb = 0; #define HERMON_QUIESCE_IBTF_CALLB(state) \ { \ uint_t count = 0; \ \ state->hs_ibtfpriv = NULL; \ while (((state)->hs_in_evcallb != 0) && \ (count++ < HERMON_QUIESCE_IBTF_CALLB_POLL_MAX)) { \ drv_usecwait(HERMON_QUIESCE_IBTF_CALLB_POLL_DELAY); \ } \ } /* * Defines used by the HERMON_QUIESCE_IBTF_CALLB() macro to determine the * duration and number of times (at maximum) to poll while waiting for IBTF * callbacks to quiesce. */ #define HERMON_QUIESCE_IBTF_CALLB_POLL_DELAY 1 #define HERMON_QUIESCE_IBTF_CALLB_POLL_MAX 1000000 /* * Macros to retrieve PCI id's of the device */ #define HERMON_DDI_PROP_GET(dip, property) \ (ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, \ property, -1)) #define HERMON_GET_VENDOR_ID(dip) HERMON_DDI_PROP_GET(dip, "vendor-id") #define HERMON_GET_DEVICE_ID(dip) HERMON_DDI_PROP_GET(dip, "device-id") #define HERMON_GET_REVISION_ID(dip) HERMON_DDI_PROP_GET(dip, "revision-id") /* * Defines used to record the device mode to which Hermon driver has been * attached. HERMON_MAINTENANCE_MODE is used when the device has * come up in the "maintenance mode". In this mode, no InfiniBand interfaces * are enabled, but the device's firmware can be updated/flashed (and * test/debug interfaces should be useable). * HERMON_HCA_MODE isused when the device has come up in the * normal HCA mode. In this mode, all necessary InfiniBand interfaces are * enabled (and, if necessary, HERMON firmware can be updated/flashed). */ #define HERMON_MAINTENANCE_MODE 1 #define HERMON_HCA_MODE 2 /* * Used to determine if the device is operational, or not in maintenance mode. * This means either the driver has attached successfully against an hermon * device in hermon compatibility mode, or against a hermon device in full HCA * mode. */ #define HERMON_IS_OPERATIONAL(mode) \ (mode == HERMON_HCA_MODE) /* * The following define is used (in hermon_umap_db_set_onclose_cb()) to * indicate that a cleanup callback is needed to undo initialization done * by the firmware flash burn code. */ #define HERMON_ONCLOSE_FLASH_INPROGRESS (1 << 0) /* * The following enumerated type and structures are used during driver * initialization. Note: The HERMON_DRV_CLEANUP_ALL type is used as a marker * for end of the cleanup steps. No cleanup steps should be added after * HERMON_DRV_CLEANUP_ALL. Any addition steps should be added before it. */ typedef enum { HERMON_DRV_CLEANUP_LEVEL0, HERMON_DRV_CLEANUP_LEVEL1, HERMON_DRV_CLEANUP_LEVEL2, HERMON_DRV_CLEANUP_LEVEL3, HERMON_DRV_CLEANUP_LEVEL4, HERMON_DRV_CLEANUP_LEVEL5, HERMON_DRV_CLEANUP_LEVEL6, HERMON_DRV_CLEANUP_LEVEL7, HERMON_DRV_CLEANUP_LEVEL8, HERMON_DRV_CLEANUP_LEVEL9, HERMON_DRV_CLEANUP_LEVEL10, HERMON_DRV_CLEANUP_LEVEL11, HERMON_DRV_CLEANUP_LEVEL12, HERMON_DRV_CLEANUP_LEVEL13, HERMON_DRV_CLEANUP_LEVEL14, HERMON_DRV_CLEANUP_LEVEL15, HERMON_DRV_CLEANUP_LEVEL16, HERMON_DRV_CLEANUP_LEVEL17, HERMON_DRV_CLEANUP_LEVEL18, HERMON_DRV_CLEANUP_LEVEL19, /* No more driver cleanup steps below this point! */ HERMON_DRV_CLEANUP_ALL } hermon_drv_cleanup_level_t; /* * The hermon_dma_info_t structure is used to store information related to * the various ICM resources' DMA allocations. The related ICM table and * virtual address are stored here. The DMA and Access handles are stored * here. Also, the allocation length and virtual (host) address. */ struct hermon_dma_info_s { ddi_dma_handle_t dma_hdl; ddi_acc_handle_t acc_hdl; uint64_t icmaddr; /* ICM virtual address */ uint64_t vaddr; /* host virtual address */ uint_t length; /* length requested */ uint_t icm_refcnt; /* refcnt */ }; _NOTE(SCHEME_PROTECTS_DATA("safe sharing", hermon_dma_info_s::icm_refcnt)) /* * The hermon_cmd_reg_t structure is used to hold the address of the each of * the most frequently accessed hardware registers. Specifically, it holds * the HCA Command Registers (HCR, used to pass command and mailbox * information back and forth to Hermon firmware) and the lock used to guarantee * mutually exclusive access to the registers. * Related to this, is the "clr_int" register which is used to clear the * interrupt once all EQs have been serviced. * Finally, there is the software reset register which is used to reinitialize * the Hermon device and to put it into a known state at driver startup time. * Below we also have the offsets (into the CMD register space) for each of * the various registers. */ typedef struct hermon_cmd_reg_s { hermon_hw_hcr_t *hcr; kmutex_t hcr_lock; uint64_t *clr_intr; uint64_t *eq_arm; uint64_t *eq_set_ci; uint32_t *sw_reset; uint32_t *sw_semaphore; uint32_t *fw_err_buf; } hermon_cmd_reg_t; _NOTE(MUTEX_PROTECTS_DATA(hermon_cmd_reg_t::hcr_lock, hermon_cmd_reg_t::hcr)) /* SOME TEMPORARY PRINTING THINGS */ #define HERMON_PRINT_CI (0x01 << 0) #define HERMON_PRINT_MEM (0x01 << 1) #define HERMON_PRINT_CQ (0x01 << 2) #define HD_PRINT(state, mask) \ if (state->hs_debug_lev & mask) /* END PRINTING THINGS */ /* * The hermon_state_t structure is the HCA software state structure. It * contains all the pointers and placeholder for everything that the HCA * driver needs to properly operate. One of these structures exists for * every instance of the HCA driver. */ struct hermon_state_s { dev_info_t *hs_dip; int hs_instance; /* PCI device, vendor, and revision IDs */ uint16_t hs_vendor_id; uint16_t hs_device_id; uint8_t hs_revision_id; /* * DMA information for the InfiniHost Context Memory (ICM), * ICM Auxiliary allocation and the firmware. Also, record * of ICM and ICMA sizes, in bytes. */ uint64_t hs_icm_sz; hermon_icm_table_t *hs_icm; uint64_t hs_icma_sz; hermon_dma_info_t hs_icma_dma; hermon_dma_info_t hs_fw_dma; /* Hermon interrupt/MSI information */ int hs_intr_types_avail; uint_t hs_intr_type_chosen; int hs_intrmsi_count; int hs_intrmsi_avail; int hs_intrmsi_allocd; ddi_intr_handle_t hs_intrmsi_hdl[HERMON_MSIX_MAX]; uint_t hs_intrmsi_pri; int hs_intrmsi_cap; ddi_cb_handle_t hs_intr_cb_hdl; /* Do not use reserved EQs */ uint_t hs_rsvd_eqs; uint_t hs_cq_erreqnum; /* cq_sched data */ kmutex_t hs_cq_sched_lock; hermon_cq_sched_t *hs_cq_sched_array; hermon_cq_sched_t hs_cq_sched_default; uint_t hs_cq_sched_array_size; /* hermon HCA name and HCA part number */ char hs_hca_name[64]; char hs_hca_pn[64]; int hs_hca_pn_len; /* Hermon device operational mode */ int hs_operational_mode; /* Attach buffer saved per state to store detailed attach errors */ char hs_attach_buf[HERMON_ATTACH_MSGSIZE]; /* Hermon NodeGUID, SystemImageGUID, and NodeDescription */ uint64_t hs_nodeguid; uint64_t hs_sysimgguid; char hs_nodedesc[64]; /* Info passed to IBTF during registration */ ibc_hca_info_t hs_ibtfinfo; ibc_clnt_hdl_t hs_ibtfpriv; /* * Hermon register mapping. Holds the device access attributes, * kernel mapped addresses, and DDI access handles for both * Hermon's CMD and UAR BARs. */ ddi_device_acc_attr_t hs_reg_accattr; caddr_t hs_reg_cmd_baseaddr; /* Hermon CMD BAR */ ddi_acc_handle_t hs_reg_cmdhdl; caddr_t hs_reg_uar_baseaddr; /* Hermon UAR BAR */ ddi_acc_handle_t hs_reg_uarhdl; caddr_t hs_reg_msi_baseaddr; /* Hermon MSIx BAR */ ddi_acc_handle_t hs_reg_msihdl; /* * Some additional things for UAR Pages */ uint64_t hs_kernel_uar_index; /* kernel UAR index */ uint64_t hs_bf_offset; /* offset from UAR */ /* Bar to Blueflame */ caddr_t hs_reg_bf_baseaddr; /* blueflame base */ ddi_acc_handle_t hs_reg_bfhdl; /* blueflame handle */ /* * Hermon PCI config space registers. This array is used to * save and restore the PCI config registers before and after a * software reset. */ uint32_t hs_cfg_data[HERMON_SW_RESET_NUMREGS]; /* for reset per Linux driver */ uint32_t hs_pci_cap_offset; uint32_t hs_pci_cap_devctl; uint32_t hs_pci_cap_lnkctl; /* * Hermon UAR page resources. Holds the resource pointers for * UAR page #0 (reserved) and for UAR page #1 (used for kernel * driver doorbells). In addition, we save a pointer to the * UAR page #1 doorbells which will be used throughout the driver * whenever it is necessary to ring one of them. And, in case we * are unable to do 64-bit writes to the page (because of system * architecture), we include a lock (to ensure atomic 64-bit access). */ hermon_rsrc_t *hs_uarpg0_rsrc_rsrvd; hermon_rsrc_t *hs_uarkpg_rsrc; hermon_hw_uar_t *hs_uar; kmutex_t hs_uar_lock; /* * Used during a call to open() if we are in maintenance mode, this * field serves as a semi-unique rolling count index value, used only * in the setup of umap_db entries. This is primarily needed to * firmware device access ioctl operations can still be guaranteed to * close in the event of an unplanned process exit, even in maintenance * mode. */ uint_t hs_open_ar_indx; /* * Hermon command registers. This structure contains the addresses * for each of the most frequently accessed CMD registers. Since * almost all accesses to the Hermon hardware are through the Hermon * command interface (i.e. the HCR), we save away the pointer to * the HCR, as well as pointers to the ECR and INT registers (as * well as their corresponding "clear" registers) for interrupt * processing. And we also save away a pointer to the software * reset register (see above). */ hermon_cmd_reg_t hs_cmd_regs; uint32_t hs_cmd_toggle; /* * Hermon resource pointers. The following are pointers to the * kmem cache (from which the Hermon resource handles are allocated), * and the array of "resource pools" (which store all the pertinent * information necessary to manage each of the various types of * resources that are used by the driver. See hermon_rsrc.h for * more detail. */ kmem_cache_t *hs_rsrc_cache; hermon_rsrc_pool_info_t *hs_rsrc_hdl; /* * Hermon mailbox lists. These hold the information necessary to * manage the pools of pre-allocated Hermon mailboxes (both "In" and * "Out" type). See hermon_cmd.h for more detail. */ hermon_mboxlist_t hs_in_mblist; hermon_mboxlist_t hs_out_mblist; /* * Hermon interrupt mailbox lists. We allocate both an "In" mailbox * and an "Out" type mailbox for the interrupt context. This is in * order to guarantee that a mailbox entry will always be available in * the interrupt context, and we can NOSLEEP without having to worry * about possible failure allocating the mbox. We create this as an * mboxlist so that we have the potential for having multiple mboxes * available based on the number of interrupts we can receive at once. */ hermon_mboxlist_t hs_in_intr_mblist; hermon_mboxlist_t hs_out_intr_mblist; /* * Hermon outstanding command list. Used to hold all the information * necessary to manage the Hermon "outstanding command list". See * hermon_cmd.h for more detail. */ hermon_cmdlist_t hs_cmd_list; /* * This structure contains the Hermon driver's "configuration profile". * This is the collected set of configuration information, such as * number of QPs, CQs, mailboxes and other resources, sizes of * individual resources, other system level configuration information, * etc. See hermon_cfg.h for more detail. */ hermon_cfg_profile_t *hs_cfg_profile; /* * This flag contains the profile setting, selecting which profile the * driver would use. This is needed in the case where we have to * fallback to a smaller profile based on some DDR conditions. If we * don't fallback, then it is set to the size of DDR in the system. */ uint32_t hs_cfg_profile_setting; /* * The following are a collection of resource handles used by the * Hermon driver (internally). First is the protection domain (PD) * handle that is used when mapping all kernel memory (work queues, * completion queues, etc). Next is an array of EQ handles. This * array is indexed by EQ number and allows the Hermon driver to quickly * convert an EQ number into the software structure associated with the * given EQ. Likewise, we have three arrays for CQ, QP and SRQ * handles. These arrays are also indexed by CQ, QP or SRQ number and * allow the driver to quickly find the corresponding CQ, QP or SRQ * software structure. Note: while the EQ table is of fixed size * (because there are a maximum of 64 EQs), each of the CQ, QP and SRQ * handle lists must be allocated at driver startup. */ hermon_pdhdl_t hs_pdhdl_internal; hermon_eqhdl_t hs_eqhdl[HERMON_NUM_EQ]; kmutex_t hs_dbr_lock; /* lock for dbr mgmt */ /* linked list of kernel dbr resources */ hermon_dbr_info_t *hs_kern_dbr; /* linked list of non-kernel dbr resources */ hermon_user_dbr_t *hs_user_dbr; /* * The AVL tree is used to store information regarding QP number * allocations. The lock protects access to the AVL tree. */ avl_tree_t hs_qpn_avl; kmutex_t hs_qpn_avl_lock; /* * This field is used to indicate whether or not the Hermon driver is * currently in an IBTF event callback elsewhere in the system. Note: * It is "volatile" because we intend to poll on this value - in * hermon_detach() - until we are assured that no further IBTF callbacks * are currently being processed. */ volatile uint32_t hs_in_evcallb; /* * The following structures are used to store the results of several * device query commands passed to the Hermon hardware at startup. * Specifically, we have hung onto the results of QUERY_DDR (which * gives information about how much DDR memory is present and where * it is located), QUERY_FW (which gives information about firmware * version numbers and the location and extent of firmware's footprint * in DDR, QUERY_DEVLIM (which gives the device limitations/resource * maximums) and QUERY_PORT (where some of the specs from DEVLIM moved), * QUERY_ADAPTER (which gives additional miscellaneous * information), and INIT/QUERY_HCA (which serves the purpose of * recording what configuration information was passed to the firmware * when the HCA was initialized). */ struct hermon_hw_queryfw_s hs_fw; struct hermon_hw_querydevlim_s hs_devlim; struct hermon_hw_query_port_s hs_queryport; struct hermon_hw_set_port_s *hs_initport; struct hermon_hw_queryadapter_s hs_adapter; struct hermon_hw_initqueryhca_s hs_hcaparams; /* * The following are used for managing special QP resources. * Specifically, we have a lock, a set of flags (in "hs_spec_qpflags") * used to track the special QP resources, and two Hermon resource * handle pointers. Each resource handle actually corresponds to two * consecutive QP contexts (one per port) for each special QP type. */ kmutex_t hs_spec_qplock; uint_t hs_spec_qpflags; hermon_rsrc_t *hs_spec_qp0; hermon_rsrc_t *hs_spec_qp1; /* * For Hermon, you have to alloc 8 qp's total, but the last 4 are * unused/reserved. The following represents the handle for those * last 4 qp's */ hermon_rsrc_t *hs_spec_qp_unused; /* * Related in some ways to the special QP handling above are these * resources which are used specifically for implementing the Hermon * agents (SMA, PMA, and BMA). Although, each of these agents does * little more that intercept the appropriate incoming MAD and forward * it along to the firmware (see hermon_agents.c for more details), we * do still use a task queue to queue them up. We can also configure * the driver to force firmware handling for certain classes of MAD, * and, therefore, we require the agent list and number of agents * in order to know what needs to be torn down at detach() time. */ hermon_agent_list_t *hs_agents; ddi_taskq_t *hs_taskq_agents; uint_t hs_num_agents; /* * Multicast group lists. These are used to track the "shadow" MCG * lists that speed up the processing of attach and detach multicast * group operations. See hermon_misc.h for more details. Note: we * need the pointer to the "temporary" MCG entry here primarily * because the size of a given MCG entry is configurable. Therefore, * it is impossible to put this variable on the stack. And rather * than allocate and deallocate the entry multiple times, we choose * instead to preallocate it once and reuse it over and over again. */ kmutex_t hs_mcglock; hermon_mcghdl_t hs_mcghdl; hermon_hw_mcg_t *hs_mcgtmp; /* * Cache of the pkey table, sgid (guid-only) tables, and * sgid (subnet) prefix. These arrays are set * during port_query, and mainly used for generating MLX GSI wqes. */ ib_pkey_t *hs_pkey[HERMON_MAX_PORTS]; ib_sn_prefix_t hs_sn_prefix[HERMON_MAX_PORTS]; ib_guid_t *hs_guid[HERMON_MAX_PORTS]; /* * Used for tracking Hermon kstat information */ hermon_ks_info_t *hs_ks_info; /* * Used for Hermon info ioctl used by VTS */ kmutex_t hs_info_lock; /* * Used for Hermon FW flash burning. They are used exclusively * within the ioctl calls for use when accessing the hermon * flash device. */ kmutex_t hs_fw_flashlock; int hs_fw_flashstarted; dev_t hs_fw_flashdev; uint32_t hs_fw_log_sector_sz; uint32_t hs_fw_device_sz; uint32_t hs_fw_flashbank; uint32_t *hs_fw_sector; uint32_t hs_fw_gpio[4]; int hs_fw_cmdset; /* * Used for Hermon FM. They are basically used to manage * the toggle switch to enable/disable Hermon FM. * Please see the comment in hermon_fm.c. */ int hs_fm_capabilities; /* FM capabilities */ int hs_fm_disable; /* Hermon FM disable flag */ int hs_fm_state; /* Hermon FM state */ boolean_t hs_fm_async_fatal; /* async internal error */ uint32_t hs_fm_async_errcnt; /* async error count */ boolean_t hs_fm_poll_suspend; /* poll thread suspend */ kmutex_t hs_fm_lock; /* mutex for state */ hermon_hca_fm_t *hs_fm_hca_fm; /* HCA FM pointer */ ddi_acc_handle_t hs_fm_cmdhdl; /* fm-protected CMD hdl */ ddi_acc_handle_t hs_fm_uarhdl; /* fm-protected UAR hdl */ ddi_device_acc_attr_t hs_fm_accattr; /* fm-protected acc attr */ ddi_periodic_t hs_fm_poll_thread; /* fma poll thread */ int32_t hs_fm_degraded_reason; /* degradation cause */ #ifdef FMA_TEST mod_hash_t *hs_fm_test_hash; /* testset */ mod_hash_t *hs_fm_id_hash; /* testid */ #endif /* FCoIB data */ hermon_fcoib_t hs_fcoib; boolean_t hs_fcoib_may_be_running; /* cq_poll test */ /* * Hermon fastreboot support. To sw-reset Hermon HCA, the driver * needs to save/restore MSI-X tables and PBA. Those members are * used for the purpose. */ /* Access handle for PCI config space */ ddi_acc_handle_t hs_reg_pcihdl; /* PCI cfg handle */ ddi_acc_handle_t hs_fm_pcihdl; /* fm handle */ ushort_t hs_caps_ptr; /* MSI-X caps */ ushort_t hs_msix_ctrl; /* MSI-X ctrl */ /* members to handle MSI-X tables */ ddi_acc_handle_t hs_reg_msix_tblhdl; /* MSI-X table handle */ ddi_acc_handle_t hs_fm_msix_tblhdl; /* fm handle */ char *hs_msix_tbl_addr; /* MSI-X table addr */ char *hs_msix_tbl_entries; /* MSI-X table entry */ size_t hs_msix_tbl_size; /* MSI-X table size */ uint32_t hs_msix_tbl_offset; /* MSI-X table offset */ uint32_t hs_msix_tbl_rnumber; /* MSI-X table reg# */ /* members to handle MSI-X PBA */ ddi_acc_handle_t hs_reg_msix_pbahdl; /* MSI-X PBA handle */ ddi_acc_handle_t hs_fm_msix_pbahdl; /* fm handle */ char *hs_msix_pba_addr; /* MSI-X PBA addr */ char *hs_msix_pba_entries; /* MSI-X PBA entry */ size_t hs_msix_pba_size; /* MSI-X PBA size */ uint32_t hs_msix_pba_offset; /* MSI-X PBA offset */ uint32_t hs_msix_pba_rnumber; /* MSI-X PBA reg# */ boolean_t hs_quiescing; /* in fastreboot */ }; _NOTE(MUTEX_PROTECTS_DATA(hermon_state_s::hs_fw_flashlock, hermon_state_s::hs_fw_flashstarted hermon_state_s::hs_fw_flashdev hermon_state_s::hs_fw_log_sector_sz hermon_state_s::hs_fw_device_sz)) _NOTE(MUTEX_PROTECTS_DATA(hermon_state_s::hs_spec_qplock, hermon_state_s::hs_spec_qpflags hermon_state_s::hs_spec_qp0 hermon_state_s::hs_spec_qp1)) _NOTE(MUTEX_PROTECTS_DATA(hermon_state_s::hs_mcglock, hermon_state_s::hs_mcghdl hermon_state_s::hs_mcgtmp)) _NOTE(DATA_READABLE_WITHOUT_LOCK(hermon_state_s::hs_in_evcallb hermon_state_s::hs_fw_log_sector_sz hermon_state_s::hs_fw_device_sz hermon_state_s::hs_spec_qpflags hermon_state_s::hs_spec_qp0 hermon_state_s::hs_spec_qp1)) _NOTE(MUTEX_PROTECTS_DATA(hermon_state_s::hs_qpn_avl_lock, hermon_state_s::hs_qpn_avl)) _NOTE(SCHEME_PROTECTS_DATA("safe sharing", hermon_state_s::hs_fm_async_fatal hermon_state_s::hs_fw_sector)) /* * HERMON_IN_FASTREBOOT() shows if Hermon driver is at fastreboot. * This macro should be used to check if the mutex lock can be used * since the lock cannot be used if the driver is in the quiesce mode. */ #define HERMON_IN_FASTREBOOT(state) (state->hs_quiescing == B_TRUE) /* * Bit positions in the "hs_spec_qpflags" field above. The flags are (from * least significant to most): (QP0,Port1), (QP0,Port2), (QP1,Port1), and * (QP1,Port2). The masks are there to help with some specific allocation * and freeing operations */ #define HERMON_SPECIAL_QP0_RSRC 0 #define HERMON_SPECIAL_QP0_RSRC_MASK 0x3 #define HERMON_SPECIAL_QP1_RSRC 2 #define HERMON_SPECIAL_QP1_RSRC_MASK 0xC /* * These flags specifies additional behaviors on database access. * HERMON_UMAP_DB_REMOVE, for example, specifies that (if found) the database * entry should be removed from the database. HERMON_UMAP_DB_IGNORE_INSTANCE * specifies that a particular database query should ignore value in the * "tdb_instance" field as a criterion for the search. */ #define HERMON_UMAP_DB_REMOVE (1 << 0) #define HERMON_UMAP_DB_IGNORE_INSTANCE (1 << 1) /* * The hermon_umap_db_t structure contains what is referred to throughout the * driver code as the "userland resources database". This structure contains * all the necessary information to track resources that have been prepared * for direct-from-userland access. There is an AVL tree ("hdl_umapdb_avl") * which consists of the "hermon_umap_db_entry_t" (below) and a lock to ensure * atomic access when adding or removing entries from the database. */ typedef struct hermon_umap_db_s { kmutex_t hdl_umapdb_lock; avl_tree_t hdl_umapdb_avl; } hermon_umap_db_t; /* * The hermon_umap_db_priv_t structure currently contains information necessary * to provide the "on close" callback to the firmware flash interfaces. It * is intended that this structure could be extended to enable other "on * close" callbacks as well. */ typedef struct hermon_umap_db_priv_s { int (*hdp_cb)(void *); void *hdp_arg; } hermon_umap_db_priv_t; /* * The hermon_umap_db_common_t structure contains fields which are common * between the database entries ("hermon_umap_db_entry_t") and the structure * used to contain the search criteria ("hermon_umap_db_query_t"). This * structure contains a key, a resource type (described above), an instance * (corresponding to the driver instance which inserted the database entry), * and a "value" field. Typically, "hdb_value" is a pointer to a Hermon * resource object. Although for memory regions, the value field corresponds * to the ddi_umem_cookie_t for the pinned userland memory. * The structure also includes a placeholder for private data ("hdb_priv"). * Currently this data is being used for holding "on close" callback * information to allow certain kinds of cleanup even if a userland process * prematurely exits. */ typedef struct hermon_umap_db_common_s { uint64_t hdb_key; uint64_t hdb_value; uint_t hdb_type; uint_t hdb_instance; void *hdb_priv; } hermon_umap_db_common_t; /* * The hermon_umap_db_entry_t structure is the entry in "userland resources * database". As required by the AVL framework, each entry contains an * "avl_node_t". Then, as required to implement the database, each entry * contains a "hermon_umap_db_common_t" structure used to contain all of the * relevant entries. */ typedef struct hermon_umap_db_entry_s { avl_node_t hdbe_avlnode; hermon_umap_db_common_t hdbe_common; } hermon_umap_db_entry_t; /* * The hermon_umap_db_query_t structure is used in queries to the "userland * resources database". In addition to the "hermon_umap_db_common_t" structure * used to contain the various search criteria, this structure also contains * a flags field "hqdb_flags" which can be used to specify additional behaviors * (as described above). Specifically, the flags field can be used to specify * that an entry should be removed from the database, if found, and to * specify whether the database lookup should consider "tdb_instance" in the * search. */ typedef struct hermon_umap_db_query_s { uint_t hqdb_flags; hermon_umap_db_common_t hqdb_common; } hermon_umap_db_query_t; _NOTE(MUTEX_PROTECTS_DATA(hermon_umap_db_s::hdl_umapdb_lock, hermon_umap_db_entry_s::hdbe_avlnode hermon_umap_db_entry_s::hdbe_common.hdb_key hermon_umap_db_entry_s::hdbe_common.hdb_value hermon_umap_db_entry_s::hdbe_common.hdb_type hermon_umap_db_entry_s::hdbe_common.hdb_instance)) /* * The hermon_devmap_track_t structure contains all the necessary information * to track resources that have been mapped through devmap. There is a * back-pointer to the Hermon softstate, the logical offset corresponding with * the mapped resource, the size of the mapped resource (zero indicates an * "invalid mapping"), and a reference count and lock used to determine when * to free the structure (specifically, this is necessary to handle partial * unmappings). */ typedef struct hermon_devmap_track_s { hermon_state_t *hdt_state; uint64_t hdt_offset; uint_t hdt_size; int hdt_refcnt; kmutex_t hdt_lock; } hermon_devmap_track_t; #define HERMON_ICM_SPLIT 64 #define HERMON_ICM_SPAN 4096 #define hermon_bitmap(bitmap, dma_info, icm_table, split_index, num_to_hdl) \ bitmap = (icm_table)->icm_bitmap[split_index]; \ if (bitmap == NULL) { \ _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*(icm_table))) \ int num_spans = (icm_table)->num_spans; \ bitmap = \ (icm_table)->icm_bitmap[split_index] = \ kmem_zalloc((num_spans + 7) / 8, KM_SLEEP); \ ASSERT((icm_table)->icm_dma[split_index] == NULL); \ (icm_table)->icm_dma[split_index] = \ kmem_zalloc(num_spans * sizeof (hermon_dma_info_t), \ KM_SLEEP); \ if (num_to_hdl) { \ ASSERT((icm_table)->num_to_hdl[split_index] == NULL); \ (icm_table)->num_to_hdl[split_index] = \ kmem_zalloc(num_spans * \ sizeof (void **), KM_SLEEP); \ } \ } \ dma_info = (icm_table)->icm_dma[split_index] /* * The hermon_icm_table_t encodes data pertaining to a given ICM table, and * holds an array of hermon_dma_info_t's related to its backing memory. Each * ICM table is sized during initialization, but real memory is allocated * and mapped into and out of ICM in the device throughout the life of the * instance. We use a bitmap to determine whether or not a given ICM object * has memory backing it or not, and an array of hermon_dma_info_t's to house * the actual allocations. Memory is allocated in chunks of span_size, stored * in the icm_dma array, and can later be looked up by using the bitmap index. * The total number of ICM spans is equal to table_size / span_size. We also * keep track of the ICM characteristics, such as ICM object size and the * number of entries in the ICM area. */ struct hermon_icm_table_s { kmutex_t icm_table_lock; kcondvar_t icm_table_cv; uint8_t icm_busy; hermon_rsrc_type_t icm_type; uint64_t icm_baseaddr; uint64_t table_size; uint64_t num_entries; /* maximum #entries */ uint32_t object_size; uint32_t span; /* #rsrc's per span */ uint32_t num_spans; /* #dmainfos in icm_dma */ uint32_t split_shift; uint32_t span_mask; uint32_t span_shift; uint32_t rsrc_mask; uint16_t log_num_entries; uint16_t log_object_size; /* three arrays of pointers, each pointer points to arrays */ uint8_t *icm_bitmap[HERMON_ICM_SPLIT]; hermon_dma_info_t *icm_dma[HERMON_ICM_SPLIT]; void ***num_to_hdl[HERMON_ICM_SPLIT]; /* qp/cq/srq */ }; /* * Split the rsrc index into three pieces: * * index1 - icm_bitmap[HERMON_ICM_SPLIT], icm_dma[HERMON_ICM_SPLIT] * index2 - bitmap[], dma[] * offset - rsrc within the icm mapping */ #define hermon_index(index1, index2, rindx, table, offset) \ index1 = (rindx) >> table->split_shift; \ index2 = ((rindx) & table->span_mask) >> table->span_shift; \ offset = (rindx) & table->rsrc_mask /* Defined in hermon.c */ int hermon_dma_alloc(hermon_state_t *state, hermon_dma_info_t *dma_info, uint16_t opcode); void hermon_dma_attr_init(hermon_state_t *state, ddi_dma_attr_t *dma_attr); void hermon_dma_free(hermon_dma_info_t *info); int hermon_icm_alloc(hermon_state_t *state, hermon_rsrc_type_t type, uint32_t icm_index1, uint32_t icm_index2); void hermon_icm_free(hermon_state_t *state, hermon_rsrc_type_t type, uint32_t icm_index1, uint32_t icm_index2); void *hermon_icm_num_to_hdl(hermon_state_t *state, hermon_rsrc_type_t type, uint32_t idx); void hermon_icm_set_num_to_hdl(hermon_state_t *state, hermon_rsrc_type_t type, uint32_t idx, void *hdl); int hermon_device_mode(hermon_state_t *state); /* Defined in hermon_umap.c */ int hermon_devmap(dev_t dev, devmap_cookie_t dhp, offset_t off, size_t len, size_t *maplen, uint_t model); ibt_status_t hermon_umap_ci_data_in(hermon_state_t *state, ibt_ci_data_flags_t flags, ibt_object_type_t object, void *hdl, void *data_p, size_t data_sz); ibt_status_t hermon_umap_ci_data_out(hermon_state_t *state, ibt_ci_data_flags_t flags, ibt_object_type_t object, void *hdl, void *data_p, size_t data_sz); void hermon_umap_db_init(void); void hermon_umap_db_fini(void); hermon_umap_db_entry_t *hermon_umap_db_alloc(uint_t instance, uint64_t key, uint_t type, uint64_t value); void hermon_umap_db_free(hermon_umap_db_entry_t *umapdb); void hermon_umap_db_add(hermon_umap_db_entry_t *umapdb); void hermon_umap_db_add_nolock(hermon_umap_db_entry_t *umapdb); int hermon_umap_db_find(uint_t instance, uint64_t key, uint_t type, uint64_t *value, uint_t flags, hermon_umap_db_entry_t **umapdb); int hermon_umap_db_find_nolock(uint_t instance, uint64_t key, uint_t type, uint64_t *value, uint_t flags, hermon_umap_db_entry_t **umapdb); void hermon_umap_umemlock_cb(ddi_umem_cookie_t *umem_cookie); int hermon_umap_db_set_onclose_cb(dev_t dev, uint64_t flag, int (*callback)(void *), void *arg); int hermon_umap_db_clear_onclose_cb(dev_t dev, uint64_t flag); int hermon_umap_db_handle_onclose_cb(hermon_umap_db_priv_t *priv); int hermon_rsrc_hw_entries_init(hermon_state_t *state, hermon_rsrc_hw_entry_info_t *info); void hermon_rsrc_hw_entries_fini(hermon_state_t *state, hermon_rsrc_hw_entry_info_t *info); #ifdef __cplusplus } #endif #endif /* _SYS_IB_ADAPTERS_HERMON_H */
