1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
|
// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
/* Copyright 2021 Marvell. All rights reserved. */
#include <linux/types.h>
#include <asm/byteorder.h>
#include <asm/param.h>
#include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <linux/etherdevice.h>
#include <linux/kernel.h>
#include <linux/log2.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/stddef.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/list.h>
#include <linux/qed/qed_nvmetcp_if.h>
#include "qed.h"
#include "qed_cxt.h"
#include "qed_dev_api.h"
#include "qed_hsi.h"
#include "qed_hw.h"
#include "qed_int.h"
#include "qed_nvmetcp.h"
#include "qed_ll2.h"
#include "qed_mcp.h"
#include "qed_sp.h"
#include "qed_reg_addr.h"
static int qed_nvmetcp_async_event(struct qed_hwfn *p_hwfn, u8 fw_event_code,
u16 echo, union event_ring_data *data,
u8 fw_return_code)
{
if (p_hwfn->p_nvmetcp_info->event_cb) {
struct qed_nvmetcp_info *p_nvmetcp = p_hwfn->p_nvmetcp_info;
return p_nvmetcp->event_cb(p_nvmetcp->event_context,
fw_event_code, data);
} else {
DP_NOTICE(p_hwfn, "nvmetcp async completion is not set\n");
return -EINVAL;
}
}
static int qed_sp_nvmetcp_func_start(struct qed_hwfn *p_hwfn,
enum spq_mode comp_mode,
struct qed_spq_comp_cb *p_comp_addr,
void *event_context,
nvmetcp_event_cb_t async_event_cb)
{
struct nvmetcp_init_ramrod_params *p_ramrod = NULL;
struct qed_nvmetcp_pf_params *p_params = NULL;
struct scsi_init_func_queues *p_queue = NULL;
struct nvmetcp_spe_func_init *p_init = NULL;
struct qed_sp_init_data init_data = {};
struct qed_spq_entry *p_ent = NULL;
int rc = 0;
u16 val;
u8 i;
/* Get SPQ entry */
init_data.cid = qed_spq_get_cid(p_hwfn);
init_data.opaque_fid = p_hwfn->hw_info.opaque_fid;
init_data.comp_mode = comp_mode;
init_data.p_comp_data = p_comp_addr;
rc = qed_sp_init_request(p_hwfn, &p_ent,
NVMETCP_RAMROD_CMD_ID_INIT_FUNC,
PROTOCOLID_TCP_ULP, &init_data);
if (rc)
return rc;
p_ramrod = &p_ent->ramrod.nvmetcp_init;
p_init = &p_ramrod->nvmetcp_init_spe;
p_params = &p_hwfn->pf_params.nvmetcp_pf_params;
p_queue = &p_init->q_params;
p_init->num_sq_pages_in_ring = p_params->num_sq_pages_in_ring;
p_init->num_r2tq_pages_in_ring = p_params->num_r2tq_pages_in_ring;
p_init->num_uhq_pages_in_ring = p_params->num_uhq_pages_in_ring;
p_init->ll2_rx_queue_id = RESC_START(p_hwfn, QED_LL2_RAM_QUEUE) +
p_params->ll2_ooo_queue_id;
SET_FIELD(p_init->flags, NVMETCP_SPE_FUNC_INIT_NVMETCP_MODE, 1);
p_init->func_params.log_page_size = ilog2(PAGE_SIZE);
p_init->func_params.num_tasks = cpu_to_le16(p_params->num_tasks);
p_init->debug_flags = p_params->debug_mode;
DMA_REGPAIR_LE(p_queue->glbl_q_params_addr,
p_params->glbl_q_params_addr);
p_queue->cq_num_entries = cpu_to_le16(QED_NVMETCP_FW_CQ_SIZE);
p_queue->num_queues = p_params->num_queues;
val = RESC_START(p_hwfn, QED_CMDQS_CQS);
p_queue->queue_relative_offset = cpu_to_le16((u16)val);
p_queue->cq_sb_pi = p_params->gl_rq_pi;
for (i = 0; i < p_params->num_queues; i++) {
val = qed_get_igu_sb_id(p_hwfn, i);
p_queue->cq_cmdq_sb_num_arr[i] = cpu_to_le16(val);
}
SET_FIELD(p_queue->q_validity,
SCSI_INIT_FUNC_QUEUES_CMD_VALID, 0);
p_queue->cmdq_num_entries = 0;
p_queue->bdq_resource_id = (u8)RESC_START(p_hwfn, QED_BDQ);
p_ramrod->tcp_init.two_msl_timer = cpu_to_le32(QED_TCP_TWO_MSL_TIMER);
p_ramrod->tcp_init.tx_sws_timer = cpu_to_le16(QED_TCP_SWS_TIMER);
p_init->half_way_close_timeout = cpu_to_le16(QED_TCP_HALF_WAY_CLOSE_TIMEOUT);
p_ramrod->tcp_init.max_fin_rt = QED_TCP_MAX_FIN_RT;
SET_FIELD(p_ramrod->nvmetcp_init_spe.params,
NVMETCP_SPE_FUNC_INIT_MAX_SYN_RT, QED_TCP_MAX_FIN_RT);
p_hwfn->p_nvmetcp_info->event_context = event_context;
p_hwfn->p_nvmetcp_info->event_cb = async_event_cb;
qed_spq_register_async_cb(p_hwfn, PROTOCOLID_TCP_ULP,
qed_nvmetcp_async_event);
return qed_spq_post(p_hwfn, p_ent, NULL);
}
static int qed_sp_nvmetcp_func_stop(struct qed_hwfn *p_hwfn,
enum spq_mode comp_mode,
struct qed_spq_comp_cb *p_comp_addr)
{
struct qed_spq_entry *p_ent = NULL;
struct qed_sp_init_data init_data;
int rc;
/* Get SPQ entry */
memset(&init_data, 0, sizeof(init_data));
init_data.cid = qed_spq_get_cid(p_hwfn);
init_data.opaque_fid = p_hwfn->hw_info.opaque_fid;
init_data.comp_mode = comp_mode;
init_data.p_comp_data = p_comp_addr;
rc = qed_sp_init_request(p_hwfn, &p_ent,
NVMETCP_RAMROD_CMD_ID_DESTROY_FUNC,
PROTOCOLID_TCP_ULP, &init_data);
if (rc)
return rc;
rc = qed_spq_post(p_hwfn, p_ent, NULL);
qed_spq_unregister_async_cb(p_hwfn, PROTOCOLID_TCP_ULP);
return rc;
}
static int qed_fill_nvmetcp_dev_info(struct qed_dev *cdev,
struct qed_dev_nvmetcp_info *info)
{
struct qed_hwfn *hwfn = QED_AFFIN_HWFN(cdev);
int rc;
memset(info, 0, sizeof(*info));
rc = qed_fill_dev_info(cdev, &info->common);
info->port_id = MFW_PORT(hwfn);
info->num_cqs = FEAT_NUM(hwfn, QED_NVMETCP_CQ);
return rc;
}
static void qed_register_nvmetcp_ops(struct qed_dev *cdev,
struct qed_nvmetcp_cb_ops *ops,
void *cookie)
{
cdev->protocol_ops.nvmetcp = ops;
cdev->ops_cookie = cookie;
}
static int qed_nvmetcp_stop(struct qed_dev *cdev)
{
int rc;
if (!(cdev->flags & QED_FLAG_STORAGE_STARTED)) {
DP_NOTICE(cdev, "nvmetcp already stopped\n");
return 0;
}
if (!hash_empty(cdev->connections)) {
DP_NOTICE(cdev,
"Can't stop nvmetcp - not all connections were returned\n");
return -EINVAL;
}
/* Stop the nvmetcp */
rc = qed_sp_nvmetcp_func_stop(QED_AFFIN_HWFN(cdev), QED_SPQ_MODE_EBLOCK,
NULL);
cdev->flags &= ~QED_FLAG_STORAGE_STARTED;
return rc;
}
static int qed_nvmetcp_start(struct qed_dev *cdev,
struct qed_nvmetcp_tid *tasks,
void *event_context,
nvmetcp_event_cb_t async_event_cb)
{
struct qed_tid_mem *tid_info;
int rc;
if (cdev->flags & QED_FLAG_STORAGE_STARTED) {
DP_NOTICE(cdev, "nvmetcp already started;\n");
return 0;
}
rc = qed_sp_nvmetcp_func_start(QED_AFFIN_HWFN(cdev),
QED_SPQ_MODE_EBLOCK, NULL,
event_context, async_event_cb);
if (rc) {
DP_NOTICE(cdev, "Failed to start nvmetcp\n");
return rc;
}
cdev->flags |= QED_FLAG_STORAGE_STARTED;
hash_init(cdev->connections);
if (!tasks)
return 0;
tid_info = kzalloc(sizeof(*tid_info), GFP_KERNEL);
if (!tid_info) {
qed_nvmetcp_stop(cdev);
return -ENOMEM;
}
rc = qed_cxt_get_tid_mem_info(QED_AFFIN_HWFN(cdev), tid_info);
if (rc) {
DP_NOTICE(cdev, "Failed to gather task information\n");
qed_nvmetcp_stop(cdev);
kfree(tid_info);
return rc;
}
/* Fill task information */
tasks->size = tid_info->tid_size;
tasks->num_tids_per_block = tid_info->num_tids_per_block;
memcpy(tasks->blocks, tid_info->blocks,
MAX_TID_BLOCKS_NVMETCP * sizeof(u8 *));
kfree(tid_info);
return 0;
}
static const struct qed_nvmetcp_ops qed_nvmetcp_ops_pass = {
.common = &qed_common_ops_pass,
.ll2 = &qed_ll2_ops_pass,
.fill_dev_info = &qed_fill_nvmetcp_dev_info,
.register_ops = &qed_register_nvmetcp_ops,
.start = &qed_nvmetcp_start,
.stop = &qed_nvmetcp_stop,
/* Placeholder - Connection level ops */
};
const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops(void)
{
return &qed_nvmetcp_ops_pass;
}
EXPORT_SYMBOL(qed_get_nvmetcp_ops);
void qed_put_nvmetcp_ops(void)
{
}
EXPORT_SYMBOL(qed_put_nvmetcp_ops);
|
