/*
* 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) 2010, Oracle and/or its affiliates. All rights reserved.
*/
/*
* hermon_fcoib.c
* Hermon Fibre Channel over IB routines
*
* Implements all the routines necessary for setting up, using, and
* (later) tearing down all the FCoIB state.
*/
#include <sys/ib/adapters/hermon/hermon.h>
/*
* hermon_fcoib_enable()
* Context: user or kernel context
*/
static int
hermon_fcoib_enable(hermon_state_t *state, int port)
{
hermon_fcoib_t *fcoib;
hermon_hw_config_fc_basic_t config_fc_basic;
int status;
port--; /* passed in as 1 or 2, used as 0 or 1 */
ASSERT(port >= 0 && port < HERMON_MAX_PORTS);
fcoib = &state->hs_fcoib;
/* Configure FCoIB on the port */
bzero(&config_fc_basic, sizeof (config_fc_basic));
config_fc_basic.fexch_base_hi = fcoib->hfc_fexch_base[port] >> 16;
config_fc_basic.fx_base_mpt_hi = fcoib->hfc_mpt_base[port] >> 17;
config_fc_basic.fx_base_mpt_lo = 0;
config_fc_basic.log2_num_rfci =
state->hs_ibtfinfo.hca_attr->hca_rfci_max_log2_qp;
config_fc_basic.rfci_base = fcoib->hfc_rfci_qps_per_port * port +
fcoib->hfc_rfci_rsrc->hr_indx;
#if 1
status = hermon_config_fc_cmd_post(state, &config_fc_basic, 1,
HERMON_HW_FC_CONF_BASIC, 0, port + 1, HERMON_CMD_NOSLEEP_SPIN);
#else
status = hermon_config_fc_cmd_post(state, &config_fc_basic, 1,
HERMON_HW_FC_CONF_BASIC, 0, 0, HERMON_CMD_NOSLEEP_SPIN);
#endif
if (status != HERMON_CMD_SUCCESS) {
cmn_err(CE_CONT, "fcoib_enable failed: status 0x%x\n", status);
HERMON_WARNING(state, "fcoib_enable failed");
return (DDI_FAILURE);
}
fcoib->hfc_port_enabled[port] = 1;
state->hs_fcoib_may_be_running = B_TRUE;
return (DDI_SUCCESS);
}
/*
* hermon_fcoib_set_id()
* Context: user or kernel context
*/
int
hermon_fcoib_set_id(hermon_state_t *state, int port, uint32_t rfci_qpn,
uint32_t src_id)
{
hermon_fcoib_t *fcoib;
int status;
int offset;
uint32_t *n_port_ids;
port--; /* passed in as 1 or 2, used as 0 or 1 */
ASSERT(port >= 0 && port < HERMON_MAX_PORTS);
fcoib = &state->hs_fcoib;
mutex_enter(&fcoib->hfc_lock);
if (fcoib->hfc_port_enabled[port] == 0) {
if (hermon_fcoib_enable(state, port + 1) != DDI_SUCCESS) {
mutex_exit(&fcoib->hfc_lock);
return (DDI_FAILURE);
}
}
n_port_ids = fcoib->hfc_n_port_ids[port];
offset = rfci_qpn - fcoib->hfc_rfci_base[port];
ASSERT(offset >= 0 && offset < fcoib->hfc_rfci_qps_per_port);
n_port_ids[offset] = src_id;
status = hermon_config_fc_cmd_post(state, n_port_ids, 1,
HERMON_HW_FC_CONF_NPORT, fcoib->hfc_rfci_qps_per_port,
port + 1, HERMON_CMD_NOSLEEP_SPIN);
if (status != HERMON_CMD_SUCCESS) {
HERMON_WARNING(state, "fcoib_set_id failed");
mutex_exit(&fcoib->hfc_lock);
return (DDI_FAILURE);
}
mutex_exit(&fcoib->hfc_lock);
return (DDI_SUCCESS);
}
/*
* hermon_fcoib_get_id_idx()
* Context: user or kernel context
*/
int
hermon_fcoib_get_id_idx(hermon_state_t *state, int port, ibt_fc_attr_t *fcp)
{
hermon_fcoib_t *fcoib;
int idx;
port--; /* passed in as 1 or 2, used as 0 or 1 */
ASSERT(port >= 0 && port < HERMON_MAX_PORTS);
fcoib = &state->hs_fcoib;
idx = fcp->fc_rfci_qpn - fcoib->hfc_rfci_base[port];
if (idx < 0 || idx >= fcoib->hfc_rfci_qps_per_port)
idx = -1;
return (idx);
}
/*
* hermon_fcoib_get_exch_base()
* Context: user or kernel context
*/
int
hermon_fcoib_check_exch_base_off(hermon_state_t *state, int port,
ibt_fc_attr_t *fcp)
{
hermon_fcoib_t *fcoib;
int exch_base_off;
port--; /* passed in as 1 or 2, used as 0 or 1 */
ASSERT(port >= 0 && port < HERMON_MAX_PORTS);
fcoib = &state->hs_fcoib;
exch_base_off = fcp->fc_exch_base_off;
if (exch_base_off >= fcoib->hfc_fexch_qps_per_port)
exch_base_off = -1;
return (exch_base_off);
}
/*
* hermon_fcoib_qpnum_from_fexch()
* Context: user, kernel, or interrupt context
*/
int
hermon_fcoib_is_fexch_qpn(hermon_state_t *state, uint_t qpnum)
{
hermon_fcoib_t *fcoib;
fcoib = &state->hs_fcoib;
qpnum -= fcoib->hfc_fexch_rsrc->hr_indx;
return (qpnum < fcoib->hfc_nports * fcoib->hfc_fexch_qps_per_port);
}
/*
* hermon_fcoib_qpnum_from_fexch()
* Context: user, kernel, or interrupt context
*/
uint_t
hermon_fcoib_qpnum_from_fexch(hermon_state_t *state, int port,
uint16_t fexch)
{
hermon_fcoib_t *fcoib;
uint_t qpnum;
port--; /* passed in as 1 or 2, used as 0 or 1 */
ASSERT(port >= 0 && port < HERMON_MAX_PORTS);
fcoib = &state->hs_fcoib;
qpnum = fexch + fcoib->hfc_fexch_base[port];
return (qpnum);
}
/*
* hermon_fcoib_qpn_to_mkey
* Context: user or kernel context
*/
uint32_t
hermon_fcoib_qpn_to_mkey(hermon_state_t *state, uint_t qpnum)
{
int i;
hermon_fcoib_t *fcoib;
uint32_t qp_indx;
fcoib = &state->hs_fcoib;
for (i = 0; i < fcoib->hfc_nports; i++) {
qp_indx = qpnum - fcoib->hfc_fexch_base[i];
if (qp_indx < fcoib->hfc_fexch_qps_per_port)
return ((qp_indx + fcoib->hfc_mpt_base[i]) << 8);
}
return ((uint32_t)-1); /* cannot get here with valid qpnum argument */
}
/*
* hermon_fcoib_fexch_relative_qpn()
* Context: user or kernel context
*/
uint32_t
hermon_fcoib_fexch_relative_qpn(hermon_state_t *state, uint8_t port,
uint32_t qp_indx)
{
port--;
ASSERT(port < HERMON_MAX_PORTS);
qp_indx -= state->hs_fcoib.hfc_fexch_base[port];
return (qp_indx);
}
/*
* hermon_fcoib_fexch_mkey_init()
* Context: user or kernel context
*/
int
hermon_fcoib_fexch_mkey_init(hermon_state_t *state, hermon_pdhdl_t pd,
uint8_t port, uint32_t qp_indx, uint_t sleep)
{
int status;
uint32_t mpt_indx;
uint_t nummtt;
uint64_t mtt_addr;
hermon_fcoib_t *fcoib;
port--;
ASSERT(port < HERMON_MAX_PORTS);
fcoib = &state->hs_fcoib;
qp_indx -= fcoib->hfc_fexch_base[port]; /* relative to FEXCH base */
if (qp_indx > fcoib->hfc_fexch_qps_per_port)
return (IBT_INVALID_PARAM);
mpt_indx = qp_indx + fcoib->hfc_mpt_base[port];
nummtt = fcoib->hfc_mtts_per_mpt;
mtt_addr = ((uint64_t)qp_indx * nummtt + fcoib->hfc_mtt_base[port]) <<
HERMON_MTT_SIZE_SHIFT;
status = hermon_mr_fexch_mpt_init(state, pd, mpt_indx,
nummtt, mtt_addr, sleep);
return (status);
}
/*
* hermon_fcoib_fexch_mkey_fini()
* Context: user or kernel context
*/
int
hermon_fcoib_fexch_mkey_fini(hermon_state_t *state, hermon_pdhdl_t pd,
uint32_t qpnum, uint_t sleep)
{
int status;
uint8_t port;
uint32_t qp_indx;
uint32_t mpt_indx;
hermon_fcoib_t *fcoib;
fcoib = &state->hs_fcoib;
for (port = 0; port < fcoib->hfc_nports; port++) {
qp_indx = qpnum - fcoib->hfc_fexch_base[port];
if (qp_indx < fcoib->hfc_fexch_qps_per_port)
goto found;
}
return (IBT_INVALID_PARAM);
found:
/* qp_indx relative to FEXCH base */
mpt_indx = qp_indx + fcoib->hfc_mpt_base[port];
status = hermon_mr_fexch_mpt_fini(state, pd, mpt_indx, sleep);
return (status);
}
/*
* hermon_fcoib_query_fc()
* Context: user or kernel context
*/
void
hermon_fcoib_query_fc(hermon_state_t *state, hermon_fcoib_t *fcoib)
{
int status;
struct hermon_hw_query_fc_s query_fc;
status = hermon_cmn_query_cmd_post(state, QUERY_FC, 0, 0, &query_fc,
sizeof (query_fc), HERMON_CMD_NOSLEEP_SPIN);
if (status == HERMON_CMD_SUCCESS) {
fcoib->hfc_log2_max_port_ids_queried = query_fc.log2_max_nports;
fcoib->hfc_log2_max_fexch_queried = query_fc.log2_max_fexch;
fcoib->hfc_log2_max_rfci_queried = query_fc.log2_max_rfci;
} else
cmn_err(CE_CONT, "!query_fc status 0x%x\n", status);
}
/*
* hermon_fcoib_init()
* Context: Only called from attach() path context
*/
int
hermon_fcoib_init(hermon_state_t *state)
{
hermon_fcoib_t *fcoib;
uint_t numports;
char string[128];
int i;
uintptr_t vmemstart = (uintptr_t)0x10000000;
/* used for fast checking for FCoIB during cqe_consume */
state->hs_fcoib_may_be_running = B_FALSE;
if ((state->hs_ibtfinfo.hca_attr->hca_flags2 & IBT_HCA2_FC) == 0)
return (DDI_SUCCESS);
fcoib = &state->hs_fcoib;
bzero(fcoib, sizeof (*fcoib));
hermon_fcoib_query_fc(state, fcoib);
mutex_init(&fcoib->hfc_lock, NULL, MUTEX_DRIVER, NULL);
mutex_enter(&fcoib->hfc_lock);
/* use a ROUND value that works on both 32 and 64-bit kernels */
fcoib->hfc_vmemstart = vmemstart;
fcoib->hfc_nports = numports = state->hs_cfg_profile->cp_num_ports;
fcoib->hfc_fexch_qps_per_port =
1 << state->hs_ibtfinfo.hca_attr->hca_fexch_max_log2_qp;
fcoib->hfc_mpts_per_port = fcoib->hfc_fexch_qps_per_port * 2;
fcoib->hfc_mtts_per_mpt =
(1 << state->hs_ibtfinfo.hca_attr->hca_fexch_max_log2_mem) >>
PAGESHIFT;
fcoib->hfc_rfci_qps_per_port =
1 << state->hs_ibtfinfo.hca_attr->hca_rfci_max_log2_qp;
if (hermon_rsrc_reserve(state, HERMON_DMPT, numports *
fcoib->hfc_mpts_per_port, HERMON_SLEEP,
&fcoib->hfc_mpt_rsrc) != DDI_SUCCESS) {
mutex_exit(&fcoib->hfc_lock);
hermon_fcoib_fini(state);
return (DDI_FAILURE);
}
/*
* Only reserve MTTs for the Primary MPTs (first half of the
* range for each port).
*/
if (hermon_rsrc_reserve(state, HERMON_MTT, numports *
fcoib->hfc_mpts_per_port * fcoib->hfc_mtts_per_mpt / 2,
HERMON_SLEEP, &fcoib->hfc_mtt_rsrc) != DDI_SUCCESS) {
mutex_exit(&fcoib->hfc_lock);
hermon_fcoib_fini(state);
return (DDI_FAILURE);
}
if (hermon_rsrc_reserve(state, HERMON_QPC, numports *
fcoib->hfc_fexch_qps_per_port, HERMON_SLEEP,
&fcoib->hfc_fexch_rsrc) != DDI_SUCCESS) {
mutex_exit(&fcoib->hfc_lock);
hermon_fcoib_fini(state);
return (DDI_FAILURE);
}
if (hermon_rsrc_reserve(state, HERMON_QPC, numports *
fcoib->hfc_rfci_qps_per_port, HERMON_SLEEP,
&fcoib->hfc_rfci_rsrc) != DDI_SUCCESS) {
mutex_exit(&fcoib->hfc_lock);
hermon_fcoib_fini(state);
return (DDI_FAILURE);
}
for (i = 0; i < numports; i++) {
fcoib->hfc_port_enabled[i] = 0;
fcoib->hfc_n_port_ids[i] = kmem_zalloc(sizeof (uint32_t) *
fcoib->hfc_rfci_qps_per_port, KM_SLEEP);
fcoib->hfc_mpt_base[i] = i * fcoib->hfc_mpts_per_port +
fcoib->hfc_mpt_rsrc->hr_indx;
/* "/ 2" is for Secondary MKEYs never used on Client side */
fcoib->hfc_mtt_base[i] = (i * fcoib->hfc_mpts_per_port *
fcoib->hfc_mtts_per_mpt / 2) + fcoib->hfc_mtt_rsrc->hr_indx;
fcoib->hfc_fexch_base[i] = i * fcoib->hfc_fexch_qps_per_port +
fcoib->hfc_fexch_rsrc->hr_indx;
fcoib->hfc_rfci_base[i] = i * fcoib->hfc_rfci_qps_per_port +
fcoib->hfc_rfci_rsrc->hr_indx;
/* init FEXCH QP rsrc pool */
(void) sprintf(string, "hermon%d_port%d_fexch_vmem",
state->hs_instance, i + 1);
fcoib->hfc_fexch_vmemp[i] = vmem_create(string,
(void *)vmemstart, fcoib->hfc_fexch_qps_per_port,
1, NULL, NULL, NULL, 0, VM_SLEEP);
/* init RFCI QP rsrc pool */
(void) sprintf(string, "hermon%d_port%d_rfci_vmem",
state->hs_instance, i + 1);
fcoib->hfc_rfci_vmemp[i] = vmem_create(string,
(void *)vmemstart, fcoib->hfc_rfci_qps_per_port,
1, NULL, NULL, NULL, 0, VM_SLEEP);
}
mutex_exit(&fcoib->hfc_lock);
return (DDI_SUCCESS);
}
/*
* hermon_fcoib_fini()
* Context: Only called from attach() and/or detach() path contexts
*/
void
hermon_fcoib_fini(hermon_state_t *state)
{
hermon_fcoib_t *fcoib;
uint_t numports;
int i;
if ((state->hs_ibtfinfo.hca_attr->hca_flags2 & IBT_HCA2_FC) == 0)
return;
fcoib = &state->hs_fcoib;
mutex_enter(&fcoib->hfc_lock);
numports = fcoib->hfc_nports;
for (i = 0; i < numports; i++) {
if (fcoib->hfc_rfci_vmemp[i])
vmem_destroy(fcoib->hfc_rfci_vmemp[i]);
if (fcoib->hfc_fexch_vmemp[i])
vmem_destroy(fcoib->hfc_fexch_vmemp[i]);
if (fcoib->hfc_n_port_ids[i])
kmem_free(fcoib->hfc_n_port_ids[i], sizeof (uint32_t) *
fcoib->hfc_rfci_qps_per_port);
/* XXX --- should we issue HERMON_HW_FC_CONF_BASIC disable? */
fcoib->hfc_port_enabled[i] = 0;
}
if (fcoib->hfc_rfci_rsrc)
hermon_rsrc_free(state, &fcoib->hfc_rfci_rsrc);
if (fcoib->hfc_fexch_rsrc)
hermon_rsrc_free(state, &fcoib->hfc_fexch_rsrc);
if (fcoib->hfc_mpt_rsrc)
hermon_rsrc_free(state, &fcoib->hfc_mpt_rsrc);
if (fcoib->hfc_mtt_rsrc)
hermon_rsrc_free(state, &fcoib->hfc_mtt_rsrc);
mutex_exit(&fcoib->hfc_lock);
mutex_destroy(&fcoib->hfc_lock);
bzero(fcoib, sizeof (*fcoib));
}