1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (C) 2012-2013 Intel Corporation
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD$");
31
32#include "nvme_private.h"
33
34void
35nvme_ctrlr_cmd_identify_controller(struct nvme_controller *ctrlr, void *payload,
36	nvme_cb_fn_t cb_fn, void *cb_arg)
37{
38	struct nvme_request *req;
39	struct nvme_command *cmd;
40
41	req = nvme_allocate_request_vaddr(payload,
42	    sizeof(struct nvme_controller_data), cb_fn, cb_arg);
43
44	cmd = &req->cmd;
45	cmd->opc = NVME_OPC_IDENTIFY;
46
47	/*
48	 * TODO: create an identify command data structure, which
49	 *  includes this CNS bit in cdw10.
50	 */
51	cmd->cdw10 = htole32(1);
52
53	nvme_ctrlr_submit_admin_request(ctrlr, req);
54}
55
56void
57nvme_ctrlr_cmd_identify_namespace(struct nvme_controller *ctrlr, uint32_t nsid,
58	void *payload, nvme_cb_fn_t cb_fn, void *cb_arg)
59{
60	struct nvme_request *req;
61	struct nvme_command *cmd;
62
63	req = nvme_allocate_request_vaddr(payload,
64	    sizeof(struct nvme_namespace_data), cb_fn, cb_arg);
65
66	cmd = &req->cmd;
67	cmd->opc = NVME_OPC_IDENTIFY;
68
69	/*
70	 * TODO: create an identify command data structure
71	 */
72	cmd->nsid = htole32(nsid);
73
74	nvme_ctrlr_submit_admin_request(ctrlr, req);
75}
76
77void
78nvme_ctrlr_cmd_create_io_cq(struct nvme_controller *ctrlr,
79    struct nvme_qpair *io_que, nvme_cb_fn_t cb_fn, void *cb_arg)
80{
81	struct nvme_request *req;
82	struct nvme_command *cmd;
83
84	req = nvme_allocate_request_null(cb_fn, cb_arg);
85
86	cmd = &req->cmd;
87	cmd->opc = NVME_OPC_CREATE_IO_CQ;
88
89	/*
90	 * TODO: create a create io completion queue command data
91	 *  structure.
92	 */
93	cmd->cdw10 = htole32(((io_que->num_entries-1) << 16) | io_que->id);
94	/* 0x3 = interrupts enabled | physically contiguous */
95	cmd->cdw11 = htole32((io_que->vector << 16) | 0x3);
96	cmd->prp1 = htole64(io_que->cpl_bus_addr);
97
98	nvme_ctrlr_submit_admin_request(ctrlr, req);
99}
100
101void
102nvme_ctrlr_cmd_create_io_sq(struct nvme_controller *ctrlr,
103    struct nvme_qpair *io_que, nvme_cb_fn_t cb_fn, void *cb_arg)
104{
105	struct nvme_request *req;
106	struct nvme_command *cmd;
107
108	req = nvme_allocate_request_null(cb_fn, cb_arg);
109
110	cmd = &req->cmd;
111	cmd->opc = NVME_OPC_CREATE_IO_SQ;
112
113	/*
114	 * TODO: create a create io submission queue command data
115	 *  structure.
116	 */
117	cmd->cdw10 = htole32(((io_que->num_entries-1) << 16) | io_que->id);
118	/* 0x1 = physically contiguous */
119	cmd->cdw11 = htole32((io_que->id << 16) | 0x1);
120	cmd->prp1 = htole64(io_que->cmd_bus_addr);
121
122	nvme_ctrlr_submit_admin_request(ctrlr, req);
123}
124
125void
126nvme_ctrlr_cmd_delete_io_cq(struct nvme_controller *ctrlr,
127    struct nvme_qpair *io_que, nvme_cb_fn_t cb_fn, void *cb_arg)
128{
129	struct nvme_request *req;
130	struct nvme_command *cmd;
131
132	req = nvme_allocate_request_null(cb_fn, cb_arg);
133
134	cmd = &req->cmd;
135	cmd->opc = NVME_OPC_DELETE_IO_CQ;
136
137	/*
138	 * TODO: create a delete io completion queue command data
139	 *  structure.
140	 */
141	cmd->cdw10 = htole32(io_que->id);
142
143	nvme_ctrlr_submit_admin_request(ctrlr, req);
144}
145
146void
147nvme_ctrlr_cmd_delete_io_sq(struct nvme_controller *ctrlr,
148    struct nvme_qpair *io_que, nvme_cb_fn_t cb_fn, void *cb_arg)
149{
150	struct nvme_request *req;
151	struct nvme_command *cmd;
152
153	req = nvme_allocate_request_null(cb_fn, cb_arg);
154
155	cmd = &req->cmd;
156	cmd->opc = NVME_OPC_DELETE_IO_SQ;
157
158	/*
159	 * TODO: create a delete io submission queue command data
160	 *  structure.
161	 */
162	cmd->cdw10 = htole32(io_que->id);
163
164	nvme_ctrlr_submit_admin_request(ctrlr, req);
165}
166
167void
168nvme_ctrlr_cmd_set_feature(struct nvme_controller *ctrlr, uint8_t feature,
169    uint32_t cdw11, uint32_t cdw12, uint32_t cdw13, uint32_t cdw14,
170    uint32_t cdw15, void *payload, uint32_t payload_size,
171    nvme_cb_fn_t cb_fn, void *cb_arg)
172{
173	struct nvme_request *req;
174	struct nvme_command *cmd;
175
176	req = nvme_allocate_request_null(cb_fn, cb_arg);
177
178	cmd = &req->cmd;
179	cmd->opc = NVME_OPC_SET_FEATURES;
180	cmd->cdw10 = htole32(feature);
181	cmd->cdw11 = htole32(cdw11);
182	cmd->cdw12 = htole32(cdw12);
183	cmd->cdw13 = htole32(cdw13);
184	cmd->cdw14 = htole32(cdw14);
185	cmd->cdw15 = htole32(cdw15);
186
187	nvme_ctrlr_submit_admin_request(ctrlr, req);
188}
189
190void
191nvme_ctrlr_cmd_get_feature(struct nvme_controller *ctrlr, uint8_t feature,
192    uint32_t cdw11, void *payload, uint32_t payload_size,
193    nvme_cb_fn_t cb_fn, void *cb_arg)
194{
195	struct nvme_request *req;
196	struct nvme_command *cmd;
197
198	req = nvme_allocate_request_null(cb_fn, cb_arg);
199
200	cmd = &req->cmd;
201	cmd->opc = NVME_OPC_GET_FEATURES;
202	cmd->cdw10 = htole32(feature);
203	cmd->cdw11 = htole32(cdw11);
204
205	nvme_ctrlr_submit_admin_request(ctrlr, req);
206}
207
208void
209nvme_ctrlr_cmd_set_num_queues(struct nvme_controller *ctrlr,
210    uint32_t num_queues, nvme_cb_fn_t cb_fn, void *cb_arg)
211{
212	uint32_t cdw11;
213
214	cdw11 = ((num_queues - 1) << 16) | (num_queues - 1);
215	nvme_ctrlr_cmd_set_feature(ctrlr, NVME_FEAT_NUMBER_OF_QUEUES, cdw11,
216	    0, 0, 0, 0, NULL, 0, cb_fn, cb_arg);
217}
218
219void
220nvme_ctrlr_cmd_set_async_event_config(struct nvme_controller *ctrlr,
221    uint32_t state, nvme_cb_fn_t cb_fn, void *cb_arg)
222{
223	uint32_t cdw11;
224
225	cdw11 = state;
226	nvme_ctrlr_cmd_set_feature(ctrlr,
227	    NVME_FEAT_ASYNC_EVENT_CONFIGURATION, cdw11, 0, 0, 0, 0, NULL, 0,
228	    cb_fn, cb_arg);
229}
230
231void
232nvme_ctrlr_cmd_set_interrupt_coalescing(struct nvme_controller *ctrlr,
233    uint32_t microseconds, uint32_t threshold, nvme_cb_fn_t cb_fn, void *cb_arg)
234{
235	uint32_t cdw11;
236
237	if ((microseconds/100) >= 0x100) {
238		nvme_printf(ctrlr, "invalid coal time %d, disabling\n",
239		    microseconds);
240		microseconds = 0;
241		threshold = 0;
242	}
243
244	if (threshold >= 0x100) {
245		nvme_printf(ctrlr, "invalid threshold %d, disabling\n",
246		    threshold);
247		threshold = 0;
248		microseconds = 0;
249	}
250
251	cdw11 = ((microseconds/100) << 8) | threshold;
252	nvme_ctrlr_cmd_set_feature(ctrlr, NVME_FEAT_INTERRUPT_COALESCING, cdw11,
253	    0, 0, 0, 0, NULL, 0, cb_fn, cb_arg);
254}
255
256void
257nvme_ctrlr_cmd_get_log_page(struct nvme_controller *ctrlr, uint8_t log_page,
258    uint32_t nsid, void *payload, uint32_t payload_size, nvme_cb_fn_t cb_fn,
259    void *cb_arg)
260{
261	struct nvme_request *req;
262	struct nvme_command *cmd;
263
264	req = nvme_allocate_request_vaddr(payload, payload_size, cb_fn, cb_arg);
265
266	cmd = &req->cmd;
267	cmd->opc = NVME_OPC_GET_LOG_PAGE;
268	cmd->nsid = htole32(nsid);
269	cmd->cdw10 = ((payload_size/sizeof(uint32_t)) - 1) << 16;
270	cmd->cdw10 |= log_page;
271	cmd->cdw10 = htole32(cmd->cdw10);
272
273	nvme_ctrlr_submit_admin_request(ctrlr, req);
274}
275
276void
277nvme_ctrlr_cmd_get_error_page(struct nvme_controller *ctrlr,
278    struct nvme_error_information_entry *payload, uint32_t num_entries,
279    nvme_cb_fn_t cb_fn, void *cb_arg)
280{
281
282	KASSERT(num_entries > 0, ("%s called with num_entries==0\n", __func__));
283
284	/* Controller's error log page entries is 0-based. */
285	KASSERT(num_entries <= (ctrlr->cdata.elpe + 1),
286	    ("%s called with num_entries=%d but (elpe+1)=%d\n", __func__,
287	    num_entries, ctrlr->cdata.elpe + 1));
288
289	if (num_entries > (ctrlr->cdata.elpe + 1))
290		num_entries = ctrlr->cdata.elpe + 1;
291
292	nvme_ctrlr_cmd_get_log_page(ctrlr, NVME_LOG_ERROR,
293	    NVME_GLOBAL_NAMESPACE_TAG, payload, sizeof(*payload) * num_entries,
294	    cb_fn, cb_arg);
295}
296
297void
298nvme_ctrlr_cmd_get_health_information_page(struct nvme_controller *ctrlr,
299    uint32_t nsid, struct nvme_health_information_page *payload,
300    nvme_cb_fn_t cb_fn, void *cb_arg)
301{
302
303	nvme_ctrlr_cmd_get_log_page(ctrlr, NVME_LOG_HEALTH_INFORMATION,
304	    nsid, payload, sizeof(*payload), cb_fn, cb_arg);
305}
306
307void
308nvme_ctrlr_cmd_get_firmware_page(struct nvme_controller *ctrlr,
309    struct nvme_firmware_page *payload, nvme_cb_fn_t cb_fn, void *cb_arg)
310{
311
312	nvme_ctrlr_cmd_get_log_page(ctrlr, NVME_LOG_FIRMWARE_SLOT,
313	    NVME_GLOBAL_NAMESPACE_TAG, payload, sizeof(*payload), cb_fn,
314	    cb_arg);
315}
316
317void
318nvme_ctrlr_cmd_abort(struct nvme_controller *ctrlr, uint16_t cid,
319    uint16_t sqid, nvme_cb_fn_t cb_fn, void *cb_arg)
320{
321	struct nvme_request *req;
322	struct nvme_command *cmd;
323
324	req = nvme_allocate_request_null(cb_fn, cb_arg);
325
326	cmd = &req->cmd;
327	cmd->opc = NVME_OPC_ABORT;
328	cmd->cdw10 = htole32((cid << 16) | sqid);
329
330	nvme_ctrlr_submit_admin_request(ctrlr, req);
331}
332