?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel: Remove some unused variables in RAID and disk drivers.
[dragonfly.git] / sys / dev / raid / mfi / mfi.c
blobd38fe2ff529761bbeb3d105a1124e90665dc2225
1 /*-
2 * Copyright (c) 2006 IronPort Systems
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26 /*-
27 * Copyright (c) 2007 LSI Corp.
28 * Copyright (c) 2007 Rajesh Prabhakaran.
29 * All rights reserved.
30 *
31 * Redistribution and use in source and binary forms, with or without
32 * modification, are permitted provided that the following conditions
33 * are met:
34 * 1. Redistributions of source code must retain the above copyright
35 * notice, this list of conditions and the following disclaimer.
36 * 2. Redistributions in binary form must reproduce the above copyright
37 * notice, this list of conditions and the following disclaimer in the
38 * documentation and/or other materials provided with the distribution.
39 *
40 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50 * SUCH DAMAGE.
51 *
52 * $FreeBSD: src/sys/dev/mfi/mfi.c,v 1.62 2011/11/09 21:53:49 delphij Exp $
53 * FreeBSD projects/head_mfi/ r233016
54 */
55
56 #include "opt_mfi.h"
57
58 #include <sys/param.h>
59 #include <sys/systm.h>
60 #include <sys/sysctl.h>
61 #include <sys/malloc.h>
62 #include <sys/kernel.h>
63 #include <sys/bus.h>
64 #include <sys/eventhandler.h>
65 #include <sys/rman.h>
66 #include <sys/bus_dma.h>
67 #include <sys/buf2.h>
68 #include <sys/uio.h>
69 #include <sys/proc.h>
70 #include <sys/signalvar.h>
71 #include <sys/device.h>
72 #include <sys/mplock2.h>
73 #include <sys/taskqueue.h>
74
75 #include <bus/cam/scsi/scsi_all.h>
76
77 #include <bus/pci/pcivar.h>
78
79 #include <dev/raid/mfi/mfireg.h>
80 #include <dev/raid/mfi/mfi_ioctl.h>
81 #include <dev/raid/mfi/mfivar.h>
82
83 static int mfi_alloc_commands(struct mfi_softc *);
84 static int mfi_comms_init(struct mfi_softc *);
85 static int mfi_get_controller_info(struct mfi_softc *);
86 static int mfi_get_log_state(struct mfi_softc *,
87 struct mfi_evt_log_state **);
88 static int mfi_parse_entries(struct mfi_softc *, int, int);
89 static int mfi_dcmd_command(struct mfi_softc *, struct mfi_command **,
90 uint32_t, void **, size_t);
91 static void mfi_data_cb(void *, bus_dma_segment_t *, int, int);
92 static void mfi_startup(void *arg);
93 static void mfi_intr(void *arg);
94 static void mfi_ldprobe(struct mfi_softc *sc);
95 static void mfi_syspdprobe(struct mfi_softc *sc);
96 static void mfi_handle_evt(void *context, int pending);
97 static int mfi_aen_register(struct mfi_softc *sc, int seq, int locale);
98 static void mfi_aen_complete(struct mfi_command *);
99 static int mfi_add_ld(struct mfi_softc *sc, int);
100 static void mfi_add_ld_complete(struct mfi_command *);
101 static int mfi_add_sys_pd(struct mfi_softc *sc, int);
102 static void mfi_add_sys_pd_complete(struct mfi_command *);
103 static struct mfi_command *mfi_bio_command(struct mfi_softc *);
104 static void mfi_bio_complete(struct mfi_command *);
105 static struct mfi_command *mfi_build_ldio(struct mfi_softc *,struct bio*);
106 static struct mfi_command *mfi_build_syspdio(struct mfi_softc *,struct bio*);
107 static int mfi_send_frame(struct mfi_softc *, struct mfi_command *);
108 static int mfi_abort(struct mfi_softc *, struct mfi_command *);
109 static int mfi_linux_ioctl_int(struct cdev *, u_long, caddr_t, int);
110 static void mfi_timeout(void *);
111 static int mfi_user_command(struct mfi_softc *,
112 struct mfi_ioc_passthru *);
113 static void mfi_enable_intr_xscale(struct mfi_softc *sc);
114 static void mfi_enable_intr_ppc(struct mfi_softc *sc);
115 static int32_t mfi_read_fw_status_xscale(struct mfi_softc *sc);
116 static int32_t mfi_read_fw_status_ppc(struct mfi_softc *sc);
117 static int mfi_check_clear_intr_xscale(struct mfi_softc *sc);
118 static int mfi_check_clear_intr_ppc(struct mfi_softc *sc);
119 static void mfi_issue_cmd_xscale(struct mfi_softc *sc, bus_addr_t bus_add,
120 uint32_t frame_cnt);
121 static void mfi_issue_cmd_ppc(struct mfi_softc *sc, bus_addr_t bus_add,
122 uint32_t frame_cnt);
123 static int mfi_config_lock(struct mfi_softc *sc, uint32_t opcode);
124 static void mfi_config_unlock(struct mfi_softc *sc, int locked);
125 static int mfi_check_command_pre(struct mfi_softc *sc, struct mfi_command *cm);
126 static void mfi_check_command_post(struct mfi_softc *sc, struct mfi_command *cm);
127 static int mfi_check_for_sscd(struct mfi_softc *sc, struct mfi_command *cm);
128
129 static void mfi_filter_detach(struct knote *);
130 static int mfi_filter_read(struct knote *, long);
131 static int mfi_filter_write(struct knote *, long);
132
133 SYSCTL_NODE(_hw, OID_AUTO, mfi, CTLFLAG_RD, 0, "MFI driver parameters");
134 static int mfi_event_locale = MFI_EVT_LOCALE_ALL;
135 TUNABLE_INT("hw.mfi.event_locale", &mfi_event_locale);
136 SYSCTL_INT(_hw_mfi, OID_AUTO, event_locale, CTLFLAG_RW, &mfi_event_locale,
137 0, "event message locale");
138
139 static int mfi_event_class = MFI_EVT_CLASS_INFO;
140 TUNABLE_INT("hw.mfi.event_class", &mfi_event_class);
141 SYSCTL_INT(_hw_mfi, OID_AUTO, event_class, CTLFLAG_RW, &mfi_event_class,
142 0, "event message class");
143
144 static int mfi_max_cmds = 128;
145 TUNABLE_INT("hw.mfi.max_cmds", &mfi_max_cmds);
146 SYSCTL_INT(_hw_mfi, OID_AUTO, max_cmds, CTLFLAG_RD, &mfi_max_cmds,
147 0, "Max commands");
148
149 static int mfi_detect_jbod_change = 1;
150 TUNABLE_INT("hw.mfi.detect_jbod_change", &mfi_detect_jbod_change);
151 SYSCTL_INT(_hw_mfi, OID_AUTO, detect_jbod_change, CTLFLAG_RW,
152 &mfi_detect_jbod_change, 0, "Detect a change to a JBOD");
153
154 /* Management interface */
155 static d_open_t mfi_open;
156 static d_close_t mfi_close;
157 static d_ioctl_t mfi_ioctl;
158 static d_kqfilter_t mfi_kqfilter;
159
160 static struct dev_ops mfi_ops = {
161 { "mfi", 0, 0 },
162 .d_open = mfi_open,
163 .d_close = mfi_close,
164 .d_ioctl = mfi_ioctl,
165 .d_kqfilter = mfi_kqfilter,
166 };
167
168 static struct filterops mfi_read_filterops =
169 { FILTEROP_ISFD, NULL, mfi_filter_detach, mfi_filter_read };
170 static struct filterops mfi_write_filterops =
171 { FILTEROP_ISFD, NULL, mfi_filter_detach, mfi_filter_write };
172
173 MALLOC_DEFINE(M_MFIBUF, "mfibuf", "Buffers for the MFI driver");
174
175 #define MFI_INQ_LENGTH SHORT_INQUIRY_LENGTH
176 struct mfi_skinny_dma_info mfi_skinny;
177
178 static void
179 mfi_enable_intr_xscale(struct mfi_softc *sc)
180 {
181 MFI_WRITE4(sc, MFI_OMSK, 0x01);
182 }
183
184 static void
185 mfi_enable_intr_ppc(struct mfi_softc *sc)
186 {
187 if (sc->mfi_flags & MFI_FLAGS_1078) {
188 MFI_WRITE4(sc, MFI_ODCR0, 0xFFFFFFFF);
189 MFI_WRITE4(sc, MFI_OMSK, ~MFI_1078_EIM);
190 } else if (sc->mfi_flags & MFI_FLAGS_GEN2) {
191 MFI_WRITE4(sc, MFI_ODCR0, 0xFFFFFFFF);
192 MFI_WRITE4(sc, MFI_OMSK, ~MFI_GEN2_EIM);
193 } else if (sc->mfi_flags & MFI_FLAGS_SKINNY) {
194 MFI_WRITE4(sc, MFI_OMSK, ~0x00000001);
195 } else {
196 panic("unknown adapter type");
197 }
198 }
199
200 static int32_t
201 mfi_read_fw_status_xscale(struct mfi_softc *sc)
202 {
203 return MFI_READ4(sc, MFI_OMSG0);
204 }
205
206 static int32_t
207 mfi_read_fw_status_ppc(struct mfi_softc *sc)
208 {
209 return MFI_READ4(sc, MFI_OSP0);
210 }
211
212 static int
213 mfi_check_clear_intr_xscale(struct mfi_softc *sc)
214 {
215 int32_t status;
216
217 status = MFI_READ4(sc, MFI_OSTS);
218 if ((status & MFI_OSTS_INTR_VALID) == 0)
219 return 1;
220
221 MFI_WRITE4(sc, MFI_OSTS, status);
222 return 0;
223 }
224
225 static int
226 mfi_check_clear_intr_ppc(struct mfi_softc *sc)
227 {
228 int32_t status;
229
230 status = MFI_READ4(sc, MFI_OSTS);
231 if (((sc->mfi_flags & MFI_FLAGS_1078) && !(status & MFI_1078_RM)) ||
232 ((sc->mfi_flags & MFI_FLAGS_GEN2) && !(status & MFI_GEN2_RM)) ||
233 ((sc->mfi_flags & MFI_FLAGS_SKINNY) && !(status & MFI_SKINNY_RM)))
234 return 1;
235
236 if (sc->mfi_flags & MFI_FLAGS_SKINNY)
237 MFI_WRITE4(sc, MFI_OSTS, status);
238 else
239 MFI_WRITE4(sc, MFI_ODCR0, status);
240 return 0;
241 }
242
243 static void
244 mfi_issue_cmd_xscale(struct mfi_softc *sc, bus_addr_t bus_add, uint32_t frame_cnt)
245 {
246 MFI_WRITE4(sc, MFI_IQP,(bus_add >>3) | frame_cnt);
247 }
248
249 static void
250 mfi_issue_cmd_ppc(struct mfi_softc *sc, bus_addr_t bus_add, uint32_t frame_cnt)
251 {
252 if (sc->mfi_flags & MFI_FLAGS_SKINNY) {
253 MFI_WRITE4(sc, MFI_IQPL, (bus_add | frame_cnt << 1) | 1);
254 MFI_WRITE4(sc, MFI_IQPH, 0x00000000);
255 } else {
256 MFI_WRITE4(sc, MFI_IQP, (bus_add | frame_cnt << 1) | 1);
257 }
258 }
259
260 int
261 mfi_transition_firmware(struct mfi_softc *sc)
262 {
263 uint32_t fw_state, cur_state;
264 int max_wait, i;
265 uint32_t cur_abs_reg_val = 0;
266 uint32_t prev_abs_reg_val = 0;
267
268 cur_abs_reg_val = sc->mfi_read_fw_status(sc);
269 fw_state = cur_abs_reg_val & MFI_FWSTATE_MASK;
270 while (fw_state != MFI_FWSTATE_READY) {
271 if (bootverbose)
272 device_printf(sc->mfi_dev, "Waiting for firmware to "
273 "become ready\n");
274 cur_state = fw_state;
275 switch (fw_state) {
276 case MFI_FWSTATE_FAULT:
277 device_printf(sc->mfi_dev, "Firmware fault\n");
278 return (ENXIO);
279 case MFI_FWSTATE_WAIT_HANDSHAKE:
280 if (sc->mfi_flags & MFI_FLAGS_SKINNY || sc->mfi_flags & MFI_FLAGS_TBOLT)
281 MFI_WRITE4(sc, MFI_SKINNY_IDB, MFI_FWINIT_CLEAR_HANDSHAKE);
282 else
283 MFI_WRITE4(sc, MFI_IDB, MFI_FWINIT_CLEAR_HANDSHAKE);
284 max_wait = MFI_RESET_WAIT_TIME;
285 break;
286 case MFI_FWSTATE_OPERATIONAL:
287 if (sc->mfi_flags & MFI_FLAGS_SKINNY || sc->mfi_flags & MFI_FLAGS_TBOLT)
288 MFI_WRITE4(sc, MFI_SKINNY_IDB, 7);
289 else
290 MFI_WRITE4(sc, MFI_IDB, MFI_FWINIT_READY);
291 max_wait = MFI_RESET_WAIT_TIME;
292 break;
293 case MFI_FWSTATE_UNDEFINED:
294 case MFI_FWSTATE_BB_INIT:
295 max_wait = MFI_RESET_WAIT_TIME;
296 break;
297 case MFI_FWSTATE_FW_INIT_2:
298 max_wait = MFI_RESET_WAIT_TIME;
299 break;
300 case MFI_FWSTATE_FW_INIT:
301 case MFI_FWSTATE_FLUSH_CACHE:
302 max_wait = MFI_RESET_WAIT_TIME;
303 break;
304 case MFI_FWSTATE_DEVICE_SCAN:
305 max_wait = MFI_RESET_WAIT_TIME; /* wait for 180 seconds */
306 prev_abs_reg_val = cur_abs_reg_val;
307 break;
308 case MFI_FWSTATE_BOOT_MESSAGE_PENDING:
309 if (sc->mfi_flags & MFI_FLAGS_SKINNY || sc->mfi_flags & MFI_FLAGS_TBOLT)
310 MFI_WRITE4(sc, MFI_SKINNY_IDB, MFI_FWINIT_HOTPLUG);
311 else
312 MFI_WRITE4(sc, MFI_IDB, MFI_FWINIT_HOTPLUG);
313 max_wait = MFI_RESET_WAIT_TIME;
314 break;
315 default:
316 device_printf(sc->mfi_dev, "Unknown firmware state %#x\n",
317 fw_state);
318 return (ENXIO);
319 }
320 for (i = 0; i < (max_wait * 10); i++) {
321 cur_abs_reg_val = sc->mfi_read_fw_status(sc);
322 fw_state = cur_abs_reg_val & MFI_FWSTATE_MASK;
323 if (fw_state == cur_state)
324 DELAY(100000);
325 else
326 break;
327 }
328 if (fw_state == MFI_FWSTATE_DEVICE_SCAN) {
329 /* Check the device scanning progress */
330 if (prev_abs_reg_val != cur_abs_reg_val)
331 continue;
332 }
333 if (fw_state == cur_state) {
334 device_printf(sc->mfi_dev, "Firmware stuck in state "
335 "%#x\n", fw_state);
336 return (ENXIO);
337 }
338 }
339 return (0);
340 }
341
342 static void
343 mfi_addr_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
344 {
345 bus_addr_t *addr;
346
347 addr = arg;
348 *addr = segs[0].ds_addr;
349 }
350
351 int
352 mfi_attach(struct mfi_softc *sc)
353 {
354 uint32_t status;
355 int error, commsz, framessz, sensesz;
356 int frames, unit, max_fw_sge;
357 uint32_t tb_mem_size = 0;
358
359 if (sc == NULL)
360 return EINVAL;
361
362 device_printf(sc->mfi_dev, "Megaraid SAS driver Ver %s \n",
363 MEGASAS_VERSION);
364
365 lockinit(&sc->mfi_io_lock, "MFI I/O lock", 0, LK_CANRECURSE);
366 lockinit(&sc->mfi_config_lock, "MFI config", 0, LK_CANRECURSE);
367 TAILQ_INIT(&sc->mfi_ld_tqh);
368 TAILQ_INIT(&sc->mfi_syspd_tqh);
369 TAILQ_INIT(&sc->mfi_evt_queue);
370 TASK_INIT(&sc->mfi_evt_task, 0, mfi_handle_evt, sc);
371 TAILQ_INIT(&sc->mfi_aen_pids);
372 TAILQ_INIT(&sc->mfi_cam_ccbq);
373
374 mfi_initq_free(sc);
375 mfi_initq_ready(sc);
376 mfi_initq_busy(sc);
377 mfi_initq_bio(sc);
378
379 sc->adpreset = 0;
380 sc->last_seq_num = 0;
381 sc->disableOnlineCtrlReset = 1;
382 sc->issuepend_done = 1;
383 sc->hw_crit_error = 0;
384
385 if (sc->mfi_flags & MFI_FLAGS_1064R) {
386 sc->mfi_enable_intr = mfi_enable_intr_xscale;
387 sc->mfi_read_fw_status = mfi_read_fw_status_xscale;
388 sc->mfi_check_clear_intr = mfi_check_clear_intr_xscale;
389 sc->mfi_issue_cmd = mfi_issue_cmd_xscale;
390 } else if (sc->mfi_flags & MFI_FLAGS_TBOLT) {
391 sc->mfi_enable_intr = mfi_tbolt_enable_intr_ppc;
392 sc->mfi_disable_intr = mfi_tbolt_disable_intr_ppc;
393 sc->mfi_read_fw_status = mfi_tbolt_read_fw_status_ppc;
394 sc->mfi_check_clear_intr = mfi_tbolt_check_clear_intr_ppc;
395 sc->mfi_issue_cmd = mfi_tbolt_issue_cmd_ppc;
396 sc->mfi_adp_reset = mfi_tbolt_adp_reset;
397 sc->mfi_tbolt = 1;
398 TAILQ_INIT(&sc->mfi_cmd_tbolt_tqh);
399 } else {
400 sc->mfi_enable_intr = mfi_enable_intr_ppc;
401 sc->mfi_read_fw_status = mfi_read_fw_status_ppc;
402 sc->mfi_check_clear_intr = mfi_check_clear_intr_ppc;
403 sc->mfi_issue_cmd = mfi_issue_cmd_ppc;
404 }
405
406
407 /* Before we get too far, see if the firmware is working */
408 if ((error = mfi_transition_firmware(sc)) != 0) {
409 device_printf(sc->mfi_dev, "Firmware not in READY state, "
410 "error %d\n", error);
411 return (ENXIO);
412 }
413
414 /* Start: LSIP200113393 */
415 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */
416 1, 0, /* algnmnt, boundary */
417 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
418 BUS_SPACE_MAXADDR, /* highaddr */
419 NULL, NULL, /* filter, filterarg */
420 MEGASAS_MAX_NAME*sizeof(bus_addr_t), /* maxsize */
421 1, /* msegments */
422 MEGASAS_MAX_NAME*sizeof(bus_addr_t), /* maxsegsize */
423 0, /* flags */
424 &sc->verbuf_h_dmat)) {
425 device_printf(sc->mfi_dev, "Cannot allocate verbuf_h_dmat DMA tag\n");
426 return (ENOMEM);
427 }
428 if (bus_dmamem_alloc(sc->verbuf_h_dmat, (void **)&sc->verbuf,
429 BUS_DMA_NOWAIT, &sc->verbuf_h_dmamap)) {
430 device_printf(sc->mfi_dev, "Cannot allocate verbuf_h_dmamap memory\n");
431 return (ENOMEM);
432 }
433 bzero(sc->verbuf, MEGASAS_MAX_NAME*sizeof(bus_addr_t));
434 bus_dmamap_load(sc->verbuf_h_dmat, sc->verbuf_h_dmamap,
435 sc->verbuf, MEGASAS_MAX_NAME*sizeof(bus_addr_t),
436 mfi_addr_cb, &sc->verbuf_h_busaddr, 0);
437 /* End: LSIP200113393 */
438
439 /*
440 * Get information needed for sizing the contiguous memory for the
441 * frame pool. Size down the sgl parameter since we know that
442 * we will never need more than what's required for MAXPHYS.
443 * It would be nice if these constants were available at runtime
444 * instead of compile time.
445 */
446 status = sc->mfi_read_fw_status(sc);
447 sc->mfi_max_fw_cmds = status & MFI_FWSTATE_MAXCMD_MASK;
448 max_fw_sge = (status & MFI_FWSTATE_MAXSGL_MASK) >> 16;
449 sc->mfi_max_sge = min(max_fw_sge, ((MFI_MAXPHYS / PAGE_SIZE) + 1));
450
451 /* ThunderBolt Support get the contiguous memory */
452
453 if (sc->mfi_flags & MFI_FLAGS_TBOLT) {
454 mfi_tbolt_init_globals(sc);
455 device_printf(sc->mfi_dev, "MaxCmd = %x MaxSgl = %x state = %x \n",
456 sc->mfi_max_fw_cmds, sc->mfi_max_sge, status);
457 tb_mem_size = mfi_tbolt_get_memory_requirement(sc);
458
459 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */
460 1, 0, /* algnmnt, boundary */
461 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
462 BUS_SPACE_MAXADDR, /* highaddr */
463 NULL, NULL, /* filter, filterarg */
464 tb_mem_size, /* maxsize */
465 1, /* msegments */
466 tb_mem_size, /* maxsegsize */
467 0, /* flags */
468 &sc->mfi_tb_dmat)) {
469 device_printf(sc->mfi_dev, "Cannot allocate comms DMA tag\n");
470 return (ENOMEM);
471 }
472 if (bus_dmamem_alloc(sc->mfi_tb_dmat, (void **)&sc->request_message_pool,
473 BUS_DMA_NOWAIT, &sc->mfi_tb_dmamap)) {
474 device_printf(sc->mfi_dev, "Cannot allocate comms memory\n");
475 return (ENOMEM);
476 }
477 bzero(sc->request_message_pool, tb_mem_size);
478 bus_dmamap_load(sc->mfi_tb_dmat, sc->mfi_tb_dmamap,
479 sc->request_message_pool, tb_mem_size, mfi_addr_cb, &sc->mfi_tb_busaddr, 0);
480
481 /* For ThunderBolt memory init */
482 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */
483 0x100, 0, /* alignmnt, boundary */
484 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
485 BUS_SPACE_MAXADDR, /* highaddr */
486 NULL, NULL, /* filter, filterarg */
487 MFI_FRAME_SIZE, /* maxsize */
488 1, /* msegments */
489 MFI_FRAME_SIZE, /* maxsegsize */
490 0, /* flags */
491 &sc->mfi_tb_init_dmat)) {
492 device_printf(sc->mfi_dev, "Cannot allocate init DMA tag\n");
493 return (ENOMEM);
494 }
495 if (bus_dmamem_alloc(sc->mfi_tb_init_dmat, (void **)&sc->mfi_tb_init,
496 BUS_DMA_NOWAIT, &sc->mfi_tb_init_dmamap)) {
497 device_printf(sc->mfi_dev, "Cannot allocate init memory\n");
498 return (ENOMEM);
499 }
500 bzero(sc->mfi_tb_init, MFI_FRAME_SIZE);
501 bus_dmamap_load(sc->mfi_tb_init_dmat, sc->mfi_tb_init_dmamap,
502 sc->mfi_tb_init, MFI_FRAME_SIZE, mfi_addr_cb,
503 &sc->mfi_tb_init_busaddr, 0);
504 if (mfi_tbolt_init_desc_pool(sc, sc->request_message_pool,
505 tb_mem_size)) {
506 device_printf(sc->mfi_dev,
507 "Thunderbolt pool preparation error\n");
508 return 0;
509 }
510
511 /*
512 Allocate DMA memory mapping for MPI2 IOC Init descriptor,
513 we are taking it diffrent from what we have allocated for Request
514 and reply descriptors to avoid confusion later
515 */
516 tb_mem_size = sizeof(struct MPI2_IOC_INIT_REQUEST);
517 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */
518 1, 0, /* algnmnt, boundary */
519 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
520 BUS_SPACE_MAXADDR, /* highaddr */
521 NULL, NULL, /* filter, filterarg */
522 tb_mem_size, /* maxsize */
523 1, /* msegments */
524 tb_mem_size, /* maxsegsize */
525 0, /* flags */
526 &sc->mfi_tb_ioc_init_dmat)) {
527 device_printf(sc->mfi_dev,
528 "Cannot allocate comms DMA tag\n");
529 return (ENOMEM);
530 }
531 if (bus_dmamem_alloc(sc->mfi_tb_ioc_init_dmat,
532 (void **)&sc->mfi_tb_ioc_init_desc,
533 BUS_DMA_NOWAIT, &sc->mfi_tb_ioc_init_dmamap)) {
534 device_printf(sc->mfi_dev, "Cannot allocate comms memory\n");
535 return (ENOMEM);
536 }
537 bzero(sc->mfi_tb_ioc_init_desc, tb_mem_size);
538 bus_dmamap_load(sc->mfi_tb_ioc_init_dmat, sc->mfi_tb_ioc_init_dmamap,
539 sc->mfi_tb_ioc_init_desc, tb_mem_size, mfi_addr_cb,
540 &sc->mfi_tb_ioc_init_busaddr, 0);
541 }
542 /*
543 * Create the dma tag for data buffers. Used both for block I/O
544 * and for various internal data queries.
545 */
546 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */
547 1, 0, /* algnmnt, boundary */
548 BUS_SPACE_MAXADDR, /* lowaddr */
549 BUS_SPACE_MAXADDR, /* highaddr */
550 NULL, NULL, /* filter, filterarg */
551 BUS_SPACE_MAXSIZE_32BIT,/* maxsize */
552 sc->mfi_max_sge, /* nsegments */
553 BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */
554 BUS_DMA_ALLOCNOW, /* flags */
555 &sc->mfi_buffer_dmat)) {
556 device_printf(sc->mfi_dev, "Cannot allocate buffer DMA tag\n");
557 return (ENOMEM);
558 }
559
560 /*
561 * Allocate DMA memory for the comms queues. Keep it under 4GB for
562 * efficiency. The mfi_hwcomms struct includes space for 1 reply queue
563 * entry, so the calculated size here will be will be 1 more than
564 * mfi_max_fw_cmds. This is apparently a requirement of the hardware.
565 */
566 commsz = (sizeof(uint32_t) * sc->mfi_max_fw_cmds) +
567 sizeof(struct mfi_hwcomms);
568 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */
569 1, 0, /* algnmnt, boundary */
570 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
571 BUS_SPACE_MAXADDR, /* highaddr */
572 NULL, NULL, /* filter, filterarg */
573 commsz, /* maxsize */
574 1, /* msegments */
575 commsz, /* maxsegsize */
576 0, /* flags */
577 &sc->mfi_comms_dmat)) {
578 device_printf(sc->mfi_dev, "Cannot allocate comms DMA tag\n");
579 return (ENOMEM);
580 }
581 if (bus_dmamem_alloc(sc->mfi_comms_dmat, (void **)&sc->mfi_comms,
582 BUS_DMA_NOWAIT, &sc->mfi_comms_dmamap)) {
583 device_printf(sc->mfi_dev, "Cannot allocate comms memory\n");
584 return (ENOMEM);
585 }
586 bzero(sc->mfi_comms, commsz);
587 bus_dmamap_load(sc->mfi_comms_dmat, sc->mfi_comms_dmamap,
588 sc->mfi_comms, commsz, mfi_addr_cb, &sc->mfi_comms_busaddr, 0);
589 /*
590 * Allocate DMA memory for the command frames. Keep them in the
591 * lower 4GB for efficiency. Calculate the size of the commands at
592 * the same time; each command is one 64 byte frame plus a set of
593 * additional frames for holding sg lists or other data.
594 * The assumption here is that the SG list will start at the second
595 * frame and not use the unused bytes in the first frame. While this
596 * isn't technically correct, it simplifies the calculation and allows
597 * for command frames that might be larger than an mfi_io_frame.
598 */
599 if (sizeof(bus_addr_t) == 8) {
600 sc->mfi_sge_size = sizeof(struct mfi_sg64);
601 sc->mfi_flags |= MFI_FLAGS_SG64;
602 } else {
603 sc->mfi_sge_size = sizeof(struct mfi_sg32);
604 }
605 if (sc->mfi_flags & MFI_FLAGS_SKINNY)
606 sc->mfi_sge_size = sizeof(struct mfi_sg_skinny);
607 frames = (sc->mfi_sge_size * sc->mfi_max_sge - 1) / MFI_FRAME_SIZE + 2;
608 sc->mfi_cmd_size = frames * MFI_FRAME_SIZE;
609 framessz = sc->mfi_cmd_size * sc->mfi_max_fw_cmds;
610 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */
611 64, 0, /* algnmnt, boundary */
612 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
613 BUS_SPACE_MAXADDR, /* highaddr */
614 NULL, NULL, /* filter, filterarg */
615 framessz, /* maxsize */
616 1, /* nsegments */
617 framessz, /* maxsegsize */
618 0, /* flags */
619 &sc->mfi_frames_dmat)) {
620 device_printf(sc->mfi_dev, "Cannot allocate frame DMA tag\n");
621 return (ENOMEM);
622 }
623 if (bus_dmamem_alloc(sc->mfi_frames_dmat, (void **)&sc->mfi_frames,
624 BUS_DMA_NOWAIT, &sc->mfi_frames_dmamap)) {
625 device_printf(sc->mfi_dev, "Cannot allocate frames memory\n");
626 return (ENOMEM);
627 }
628 bzero(sc->mfi_frames, framessz);
629 bus_dmamap_load(sc->mfi_frames_dmat, sc->mfi_frames_dmamap,
630 sc->mfi_frames, framessz, mfi_addr_cb, &sc->mfi_frames_busaddr,0);
631 /*
632 * Allocate DMA memory for the frame sense data. Keep them in the
633 * lower 4GB for efficiency
634 */
635 sensesz = sc->mfi_max_fw_cmds * MFI_SENSE_LEN;
636 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */
637 4, 0, /* algnmnt, boundary */
638 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
639 BUS_SPACE_MAXADDR, /* highaddr */
640 NULL, NULL, /* filter, filterarg */
641 sensesz, /* maxsize */
642 1, /* nsegments */
643 sensesz, /* maxsegsize */
644 0, /* flags */
645 &sc->mfi_sense_dmat)) {
646 device_printf(sc->mfi_dev, "Cannot allocate sense DMA tag\n");
647 return (ENOMEM);
648 }
649 if (bus_dmamem_alloc(sc->mfi_sense_dmat, (void **)&sc->mfi_sense,
650 BUS_DMA_NOWAIT, &sc->mfi_sense_dmamap)) {
651 device_printf(sc->mfi_dev, "Cannot allocate sense memory\n");
652 return (ENOMEM);
653 }
654 bus_dmamap_load(sc->mfi_sense_dmat, sc->mfi_sense_dmamap,
655 sc->mfi_sense, sensesz, mfi_addr_cb, &sc->mfi_sense_busaddr, 0);
656 if ((error = mfi_alloc_commands(sc)) != 0)
657 return (error);
658
659 /*
660 * Before moving the FW to operational state, check whether
661 * hostmemory is required by the FW or not
662 */
663
664 /* ThunderBolt MFI_IOC2 INIT */
665 if (sc->mfi_flags & MFI_FLAGS_TBOLT) {
666 sc->mfi_disable_intr(sc);
667 if ((error = mfi_tbolt_init_MFI_queue(sc)) != 0) {
668 device_printf(sc->mfi_dev,
669 "TB Init has failed with error %d\n",error);
670 return error;
671 }
672
673 if ((error = mfi_tbolt_alloc_cmd(sc)) != 0)
674 return error;
675 if (bus_setup_intr(sc->mfi_dev, sc->mfi_irq, INTR_MPSAFE,
676 mfi_intr_tbolt, sc, &sc->mfi_intr, NULL)) {
677 device_printf(sc->mfi_dev, "Cannot set up interrupt\n");
678 return (EINVAL);
679 }
680 sc->mfi_enable_intr(sc);
681 sc->map_id = 0;
682 } else {
683 if ((error = mfi_comms_init(sc)) != 0)
684 return (error);
685
686 if (bus_setup_intr(sc->mfi_dev, sc->mfi_irq, INTR_MPSAFE,
687 mfi_intr, sc, &sc->mfi_intr, NULL)) {
688 device_printf(sc->mfi_dev, "Cannot set up interrupt\n");
689 return (EINVAL);
690 }
691 sc->mfi_enable_intr(sc);
692 }
693 if ((error = mfi_get_controller_info(sc)) != 0)
694 return (error);
695 sc->disableOnlineCtrlReset = 0;
696
697 /* Register a config hook to probe the bus for arrays */
698 sc->mfi_ich.ich_func = mfi_startup;
699 sc->mfi_ich.ich_arg = sc;
700 sc->mfi_ich.ich_desc = "mfi";
701 if (config_intrhook_establish(&sc->mfi_ich) != 0) {
702 device_printf(sc->mfi_dev, "Cannot establish configuration "
703 "hook\n");
704 return (EINVAL);
705 }
706 if ((error = mfi_aen_setup(sc, 0), 0) != 0) {
707 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
708 return (error);
709 }
710
711 /*
712 * Register a shutdown handler.
713 */
714 if ((sc->mfi_eh = EVENTHANDLER_REGISTER(shutdown_final, mfi_shutdown,
715 sc, SHUTDOWN_PRI_DEFAULT)) == NULL) {
716 device_printf(sc->mfi_dev, "Warning: shutdown event "
717 "registration failed\n");
718 }
719
720 /*
721 * Create the control device for doing management
722 */
723 unit = device_get_unit(sc->mfi_dev);
724 sc->mfi_cdev = make_dev(&mfi_ops, unit, UID_ROOT, GID_OPERATOR,
725 0640, "mfi%d", unit);
726 if (unit == 0)
727 make_dev_alias(sc->mfi_cdev, "megaraid_sas_ioctl_node");
728 if (sc->mfi_cdev != NULL)
729 sc->mfi_cdev->si_drv1 = sc;
730 sysctl_ctx_init(&sc->mfi_sysctl_ctx);
731 sc->mfi_sysctl_tree = SYSCTL_ADD_NODE(&sc->mfi_sysctl_ctx,
732 SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
733 device_get_nameunit(sc->mfi_dev), CTLFLAG_RD, 0, "");
734 if (sc->mfi_sysctl_tree == NULL) {
735 device_printf(sc->mfi_dev, "can't add sysctl node\n");
736 return (EINVAL);
737 }
738 SYSCTL_ADD_INT(&sc->mfi_sysctl_ctx,
739 SYSCTL_CHILDREN(sc->mfi_sysctl_tree),
740 OID_AUTO, "delete_busy_volumes", CTLFLAG_RW,
741 &sc->mfi_delete_busy_volumes, 0, "Allow removal of busy volumes");
742 SYSCTL_ADD_INT(&sc->mfi_sysctl_ctx,
743 SYSCTL_CHILDREN(sc->mfi_sysctl_tree),
744 OID_AUTO, "keep_deleted_volumes", CTLFLAG_RW,
745 &sc->mfi_keep_deleted_volumes, 0,
746 "Don't detach the mfid device for a busy volume that is deleted");
747
748 device_add_child(sc->mfi_dev, "mfip", -1);
749 bus_generic_attach(sc->mfi_dev);
750
751 /* Start the timeout watchdog */
752 callout_init_mp(&sc->mfi_watchdog_callout);
753 callout_reset(&sc->mfi_watchdog_callout, MFI_CMD_TIMEOUT * hz,
754 mfi_timeout, sc);
755
756 return (0);
757 }
758
759 static int
760 mfi_alloc_commands(struct mfi_softc *sc)
761 {
762 struct mfi_command *cm;
763 int i, ncmds;
764
765 /*
766 * XXX Should we allocate all the commands up front, or allocate on
767 * demand later like 'aac' does?
768 */
769 ncmds = MIN(mfi_max_cmds, sc->mfi_max_fw_cmds);
770 if (bootverbose)
771 device_printf(sc->mfi_dev, "Max fw cmds= %d, sizing driver "
772 "pool to %d\n", sc->mfi_max_fw_cmds, ncmds);
773
774 sc->mfi_commands = kmalloc(sizeof(struct mfi_command) * ncmds, M_MFIBUF,
775 M_WAITOK | M_ZERO);
776
777 for (i = 0; i < ncmds; i++) {
778 cm = &sc->mfi_commands[i];
779 cm->cm_frame = (union mfi_frame *)((uintptr_t)sc->mfi_frames +
780 sc->mfi_cmd_size * i);
781 cm->cm_frame_busaddr = sc->mfi_frames_busaddr +
782 sc->mfi_cmd_size * i;
783 cm->cm_frame->header.context = i;
784 cm->cm_sense = &sc->mfi_sense[i];
785 cm->cm_sense_busaddr= sc->mfi_sense_busaddr + MFI_SENSE_LEN * i;
786 cm->cm_sc = sc;
787 cm->cm_index = i;
788 if (bus_dmamap_create(sc->mfi_buffer_dmat, 0,
789 &cm->cm_dmamap) == 0) {
790 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
791 mfi_release_command(cm);
792 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
793 }
794 else
795 break;
796 sc->mfi_total_cmds++;
797 }
798
799 return (0);
800 }
801
802 void
803 mfi_release_command(struct mfi_command *cm)
804 {
805 struct mfi_frame_header *hdr;
806 uint32_t *hdr_data;
807
808 mfi_lockassert(&cm->cm_sc->mfi_io_lock);
809
810 /*
811 * Zero out the important fields of the frame, but make sure the
812 * context field is preserved. For efficiency, handle the fields
813 * as 32 bit words. Clear out the first S/G entry too for safety.
814 */
815 hdr = &cm->cm_frame->header;
816 if (cm->cm_data != NULL && hdr->sg_count) {
817 cm->cm_sg->sg32[0].len = 0;
818 cm->cm_sg->sg32[0].addr = 0;
819 }
820
821 hdr_data = (uint32_t *)cm->cm_frame;
822 hdr_data[0] = 0; /* cmd, sense_len, cmd_status, scsi_status */
823 hdr_data[1] = 0; /* target_id, lun_id, cdb_len, sg_count */
824 hdr_data[4] = 0; /* flags, timeout */
825 hdr_data[5] = 0; /* data_len */
826
827 cm->cm_extra_frames = 0;
828 cm->cm_flags = 0;
829 cm->cm_complete = NULL;
830 cm->cm_private = NULL;
831 cm->cm_data = NULL;
832 cm->cm_sg = 0;
833 cm->cm_total_frame_size = 0;
834 cm->retry_for_fw_reset = 0;
835
836 mfi_enqueue_free(cm);
837 }
838
839 static int
840 mfi_dcmd_command(struct mfi_softc *sc, struct mfi_command **cmp,
841 uint32_t opcode, void **bufp, size_t bufsize)
842 {
843 struct mfi_command *cm;
844 struct mfi_dcmd_frame *dcmd;
845 void *buf = NULL;
846 uint32_t context = 0;
847
848 mfi_lockassert(&sc->mfi_io_lock);
849
850 cm = mfi_dequeue_free(sc);
851 if (cm == NULL)
852 return (EBUSY);
853
854 /* Zero out the MFI frame */
855 context = cm->cm_frame->header.context;
856 bzero(cm->cm_frame, sizeof(union mfi_frame));
857 cm->cm_frame->header.context = context;
858
859 if ((bufsize > 0) && (bufp != NULL)) {
860 if (*bufp == NULL) {
861 buf = kmalloc(bufsize, M_MFIBUF, M_NOWAIT|M_ZERO);
862 if (buf == NULL) {
863 mfi_release_command(cm);
864 return (ENOMEM);
865 }
866 *bufp = buf;
867 } else {
868 buf = *bufp;
869 }
870 }
871
872 dcmd = &cm->cm_frame->dcmd;
873 bzero(dcmd->mbox, MFI_MBOX_SIZE);
874 dcmd->header.cmd = MFI_CMD_DCMD;
875 dcmd->header.timeout = 0;
876 dcmd->header.flags = 0;
877 dcmd->header.data_len = bufsize;
878 dcmd->header.scsi_status = 0;
879 dcmd->opcode = opcode;
880 cm->cm_sg = &dcmd->sgl;
881 cm->cm_total_frame_size = MFI_DCMD_FRAME_SIZE;
882 cm->cm_flags = 0;
883 cm->cm_data = buf;
884 cm->cm_private = buf;
885 cm->cm_len = bufsize;
886
887 *cmp = cm;
888 if ((bufp != NULL) && (*bufp == NULL) && (buf != NULL))
889 *bufp = buf;
890 return (0);
891 }
892
893 static int
894 mfi_comms_init(struct mfi_softc *sc)
895 {
896 struct mfi_command *cm;
897 struct mfi_init_frame *init;
898 struct mfi_init_qinfo *qinfo;
899 int error;
900 uint32_t context = 0;
901
902 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
903 if ((cm = mfi_dequeue_free(sc)) == NULL)
904 return (EBUSY);
905
906 /* Zero out the MFI frame */
907 context = cm->cm_frame->header.context;
908 bzero(cm->cm_frame, sizeof(union mfi_frame));
909 cm->cm_frame->header.context = context;
910
911 /*
912 * Abuse the SG list area of the frame to hold the init_qinfo
913 * object;
914 */
915 init = &cm->cm_frame->init;
916 qinfo = (struct mfi_init_qinfo *)((uintptr_t)init + MFI_FRAME_SIZE);
917
918 bzero(qinfo, sizeof(struct mfi_init_qinfo));
919 qinfo->rq_entries = sc->mfi_max_fw_cmds + 1;
920 qinfo->rq_addr_lo = sc->mfi_comms_busaddr +
921 offsetof(struct mfi_hwcomms, hw_reply_q);
922 qinfo->pi_addr_lo = sc->mfi_comms_busaddr +
923 offsetof(struct mfi_hwcomms, hw_pi);
924 qinfo->ci_addr_lo = sc->mfi_comms_busaddr +
925 offsetof(struct mfi_hwcomms, hw_ci);
926
927 init->header.cmd = MFI_CMD_INIT;
928 init->header.data_len = sizeof(struct mfi_init_qinfo);
929 init->qinfo_new_addr_lo = cm->cm_frame_busaddr + MFI_FRAME_SIZE;
930 cm->cm_data = NULL;
931 cm->cm_flags = MFI_CMD_POLLED;
932
933 if ((error = mfi_mapcmd(sc, cm)) != 0) {
934 device_printf(sc->mfi_dev, "failed to send init command\n");
935 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
936 return (error);
937 }
938 mfi_release_command(cm);
939 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
940
941 return (0);
942 }
943
944 static int
945 mfi_get_controller_info(struct mfi_softc *sc)
946 {
947 struct mfi_command *cm = NULL;
948 struct mfi_ctrl_info *ci = NULL;
949 uint32_t max_sectors_1, max_sectors_2;
950 int error;
951
952 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
953 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_GETINFO,
954 (void **)&ci, sizeof(*ci));
955 if (error)
956 goto out;
957 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED;
958
959 if ((error = mfi_mapcmd(sc, cm)) != 0) {
960 device_printf(sc->mfi_dev, "Failed to get controller info\n");
961 sc->mfi_max_io = (sc->mfi_max_sge - 1) * PAGE_SIZE /
962 MFI_SECTOR_LEN;
963 error = 0;
964 goto out;
965 }
966
967 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
968 BUS_DMASYNC_POSTREAD);
969 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
970
971 max_sectors_1 = (1 << ci->stripe_sz_ops.max) * ci->max_strips_per_io;
972 max_sectors_2 = ci->max_request_size;
973 sc->mfi_max_io = min(max_sectors_1, max_sectors_2);
974 sc->disableOnlineCtrlReset =
975 ci->properties.OnOffProperties.disableOnlineCtrlReset;
976
977 out:
978 if (ci)
979 kfree(ci, M_MFIBUF);
980 if (cm)
981 mfi_release_command(cm);
982 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
983 return (error);
984 }
985
986 static int
987 mfi_get_log_state(struct mfi_softc *sc, struct mfi_evt_log_state **log_state)
988 {
989 struct mfi_command *cm = NULL;
990 int error;
991
992 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
993 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_EVENT_GETINFO,
994 (void **)log_state, sizeof(**log_state));
995 if (error)
996 goto out;
997 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED;
998
999 if ((error = mfi_mapcmd(sc, cm)) != 0) {
1000 device_printf(sc->mfi_dev, "Failed to get log state\n");
1001 goto out;
1002 }
1003
1004 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
1005 BUS_DMASYNC_POSTREAD);
1006 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
1007
1008 out:
1009 if (cm)
1010 mfi_release_command(cm);
1011 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1012
1013 return (error);
1014 }
1015
1016 int
1017 mfi_aen_setup(struct mfi_softc *sc, uint32_t seq_start)
1018 {
1019 struct mfi_evt_log_state *log_state = NULL;
1020 union mfi_evt class_locale;
1021 int error = 0;
1022 uint32_t seq;
1023
1024 class_locale.members.reserved = 0;
1025 class_locale.members.locale = mfi_event_locale;
1026 class_locale.members.evt_class = mfi_event_class;
1027
1028 if (seq_start == 0) {
1029 error = mfi_get_log_state(sc, &log_state);
1030 sc->mfi_boot_seq_num = log_state->boot_seq_num;
1031 if (error) {
1032 if (log_state)
1033 kfree(log_state, M_MFIBUF);
1034 return (error);
1035 }
1036
1037 /*
1038 * Walk through any events that fired since the last
1039 * shutdown.
1040 */
1041 mfi_parse_entries(sc, log_state->shutdown_seq_num,
1042 log_state->newest_seq_num);
1043 seq = log_state->newest_seq_num;
1044 } else
1045 seq = seq_start;
1046 mfi_aen_register(sc, seq, class_locale.word);
1047 if (log_state != NULL)
1048 kfree(log_state, M_MFIBUF);
1049
1050 return 0;
1051 }
1052
1053 int
1054 mfi_wait_command(struct mfi_softc *sc, struct mfi_command *cm)
1055 {
1056
1057 mfi_lockassert(&sc->mfi_io_lock);
1058 cm->cm_complete = NULL;
1059
1060
1061 /*
1062 * MegaCli can issue a DCMD of 0. In this case do nothing
1063 * and return 0 to it as status
1064 */
1065 if (cm->cm_frame->dcmd.opcode == 0) {
1066 cm->cm_frame->header.cmd_status = MFI_STAT_OK;
1067 cm->cm_error = 0;
1068 return (cm->cm_error);
1069 }
1070 mfi_enqueue_ready(cm);
1071 mfi_startio(sc);
1072 if ((cm->cm_flags & MFI_CMD_COMPLETED) == 0)
1073 lksleep(cm, &sc->mfi_io_lock, 0, "mfiwait", 0);
1074 return (cm->cm_error);
1075 }
1076
1077 void
1078 mfi_free(struct mfi_softc *sc)
1079 {
1080 struct mfi_command *cm;
1081 int i;
1082
1083 callout_stop(&sc->mfi_watchdog_callout); /* XXX callout_drain() */
1084
1085 if (sc->mfi_cdev != NULL)
1086 destroy_dev(sc->mfi_cdev);
1087 dev_ops_remove_minor(&mfi_ops, device_get_unit(sc->mfi_dev));
1088
1089 if (sc->mfi_total_cmds != 0) {
1090 for (i = 0; i < sc->mfi_total_cmds; i++) {
1091 cm = &sc->mfi_commands[i];
1092 bus_dmamap_destroy(sc->mfi_buffer_dmat, cm->cm_dmamap);
1093 }
1094 kfree(sc->mfi_commands, M_MFIBUF);
1095 }
1096
1097 if (sc->mfi_intr)
1098 bus_teardown_intr(sc->mfi_dev, sc->mfi_irq, sc->mfi_intr);
1099 if (sc->mfi_irq != NULL)
1100 bus_release_resource(sc->mfi_dev, SYS_RES_IRQ, sc->mfi_irq_rid,
1101 sc->mfi_irq);
1102
1103 if (sc->mfi_sense_busaddr != 0)
1104 bus_dmamap_unload(sc->mfi_sense_dmat, sc->mfi_sense_dmamap);
1105 if (sc->mfi_sense != NULL)
1106 bus_dmamem_free(sc->mfi_sense_dmat, sc->mfi_sense,
1107 sc->mfi_sense_dmamap);
1108 if (sc->mfi_sense_dmat != NULL)
1109 bus_dma_tag_destroy(sc->mfi_sense_dmat);
1110
1111 if (sc->mfi_frames_busaddr != 0)
1112 bus_dmamap_unload(sc->mfi_frames_dmat, sc->mfi_frames_dmamap);
1113 if (sc->mfi_frames != NULL)
1114 bus_dmamem_free(sc->mfi_frames_dmat, sc->mfi_frames,
1115 sc->mfi_frames_dmamap);
1116 if (sc->mfi_frames_dmat != NULL)
1117 bus_dma_tag_destroy(sc->mfi_frames_dmat);
1118
1119 if (sc->mfi_comms_busaddr != 0)
1120 bus_dmamap_unload(sc->mfi_comms_dmat, sc->mfi_comms_dmamap);
1121 if (sc->mfi_comms != NULL)
1122 bus_dmamem_free(sc->mfi_comms_dmat, sc->mfi_comms,
1123 sc->mfi_comms_dmamap);
1124 if (sc->mfi_comms_dmat != NULL)
1125 bus_dma_tag_destroy(sc->mfi_comms_dmat);
1126
1127 /* ThunderBolt contiguous memory free here */
1128 if (sc->mfi_flags & MFI_FLAGS_TBOLT) {
1129 if (sc->mfi_tb_busaddr != 0)
1130 bus_dmamap_unload(sc->mfi_tb_dmat, sc->mfi_tb_dmamap);
1131 if (sc->request_message_pool != NULL)
1132 bus_dmamem_free(sc->mfi_tb_dmat, sc->request_message_pool,
1133 sc->mfi_tb_dmamap);
1134 if (sc->mfi_tb_dmat != NULL)
1135 bus_dma_tag_destroy(sc->mfi_tb_dmat);
1136
1137 /* Version buffer memory free */
1138 /* Start LSIP200113393 */
1139 if (sc->verbuf_h_busaddr != 0)
1140 bus_dmamap_unload(sc->verbuf_h_dmat, sc->verbuf_h_dmamap);
1141 if (sc->verbuf != NULL)
1142 bus_dmamem_free(sc->verbuf_h_dmat, sc->verbuf,
1143 sc->verbuf_h_dmamap);
1144 if (sc->verbuf_h_dmat != NULL)
1145 bus_dma_tag_destroy(sc->verbuf_h_dmat);
1146
1147 /* End LSIP200113393 */
1148 /* ThunderBolt INIT packet memory Free */
1149 if (sc->mfi_tb_init_busaddr != 0)
1150 bus_dmamap_unload(sc->mfi_tb_init_dmat, sc->mfi_tb_init_dmamap);
1151 if (sc->mfi_tb_init != NULL)
1152 bus_dmamem_free(sc->mfi_tb_init_dmat, sc->mfi_tb_init,
1153 sc->mfi_tb_init_dmamap);
1154 if (sc->mfi_tb_init_dmat != NULL)
1155 bus_dma_tag_destroy(sc->mfi_tb_init_dmat);
1156
1157 /* ThunderBolt IOC Init Desc memory free here */
1158 if (sc->mfi_tb_ioc_init_busaddr != 0)
1159 bus_dmamap_unload(sc->mfi_tb_ioc_init_dmat,
1160 sc->mfi_tb_ioc_init_dmamap);
1161 if (sc->mfi_tb_ioc_init_desc != NULL)
1162 bus_dmamem_free(sc->mfi_tb_ioc_init_dmat,
1163 sc->mfi_tb_ioc_init_desc,
1164 sc->mfi_tb_ioc_init_dmamap);
1165 if (sc->mfi_tb_ioc_init_dmat != NULL)
1166 bus_dma_tag_destroy(sc->mfi_tb_ioc_init_dmat);
1167 for (int i = 0; i < sc->mfi_max_fw_cmds; i++) {
1168 if (sc->mfi_cmd_pool_tbolt != NULL) {
1169 if (sc->mfi_cmd_pool_tbolt[i] != NULL) {
1170 kfree(sc->mfi_cmd_pool_tbolt[i],
1171 M_MFIBUF);
1172 sc->mfi_cmd_pool_tbolt[i] = NULL;
1173 }
1174 }
1175 }
1176 if (sc->mfi_cmd_pool_tbolt != NULL) {
1177 kfree(sc->mfi_cmd_pool_tbolt, M_MFIBUF);
1178 sc->mfi_cmd_pool_tbolt = NULL;
1179 }
1180 if (sc->request_desc_pool != NULL) {
1181 kfree(sc->request_desc_pool, M_MFIBUF);
1182 sc->request_desc_pool = NULL;
1183 }
1184 }
1185 if (sc->mfi_buffer_dmat != NULL)
1186 bus_dma_tag_destroy(sc->mfi_buffer_dmat);
1187 if (sc->mfi_parent_dmat != NULL)
1188 bus_dma_tag_destroy(sc->mfi_parent_dmat);
1189
1190 if (sc->mfi_sysctl_tree != NULL)
1191 sysctl_ctx_free(&sc->mfi_sysctl_ctx);
1192
1193 #if 0 /* XXX swildner: not sure if we need something like mtx_initialized() */
1194 if (mtx_initialized(&sc->mfi_io_lock))
1195 #endif
1196 {
1197 lockuninit(&sc->mfi_io_lock);
1198 lockuninit(&sc->mfi_config_lock);
1199 }
1200
1201 return;
1202 }
1203
1204 static void
1205 mfi_startup(void *arg)
1206 {
1207 struct mfi_softc *sc;
1208
1209 sc = (struct mfi_softc *)arg;
1210
1211 config_intrhook_disestablish(&sc->mfi_ich);
1212
1213 sc->mfi_enable_intr(sc);
1214 lockmgr(&sc->mfi_config_lock, LK_EXCLUSIVE);
1215 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1216 mfi_ldprobe(sc);
1217 if (sc->mfi_flags & MFI_FLAGS_SKINNY)
1218 mfi_syspdprobe(sc);
1219 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1220 lockmgr(&sc->mfi_config_lock, LK_RELEASE);
1221 }
1222
1223 static void
1224 mfi_intr(void *arg)
1225 {
1226 struct mfi_softc *sc;
1227 struct mfi_command *cm;
1228 uint32_t pi, ci, context;
1229
1230 sc = (struct mfi_softc *)arg;
1231
1232 if (sc->mfi_check_clear_intr(sc))
1233 return;
1234
1235 restart:
1236 pi = sc->mfi_comms->hw_pi;
1237 ci = sc->mfi_comms->hw_ci;
1238 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1239 while (ci != pi) {
1240 context = sc->mfi_comms->hw_reply_q[ci];
1241 if (context < sc->mfi_max_fw_cmds) {
1242 cm = &sc->mfi_commands[context];
1243 mfi_remove_busy(cm);
1244 cm->cm_error = 0;
1245 mfi_complete(sc, cm);
1246 }
1247 if (++ci == (sc->mfi_max_fw_cmds + 1)) {
1248 ci = 0;
1249 }
1250 }
1251
1252 sc->mfi_comms->hw_ci = ci;
1253
1254 /* Give defered I/O a chance to run */
1255 if (sc->mfi_flags & MFI_FLAGS_QFRZN)
1256 sc->mfi_flags &= ~MFI_FLAGS_QFRZN;
1257 mfi_startio(sc);
1258 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1259
1260 /*
1261 * Dummy read to flush the bus; this ensures that the indexes are up
1262 * to date. Restart processing if more commands have come it.
1263 */
1264 (void)sc->mfi_read_fw_status(sc);
1265 if (pi != sc->mfi_comms->hw_pi)
1266 goto restart;
1267
1268 return;
1269 }
1270
1271 int
1272 mfi_shutdown(struct mfi_softc *sc)
1273 {
1274 struct mfi_dcmd_frame *dcmd;
1275 struct mfi_command *cm;
1276 int error;
1277
1278 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1279 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_SHUTDOWN, NULL, 0);
1280 if (error) {
1281 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1282 return (error);
1283 }
1284
1285 if (sc->mfi_aen_cm != NULL)
1286 mfi_abort(sc, sc->mfi_aen_cm);
1287
1288 if (sc->map_update_cmd != NULL)
1289 mfi_abort(sc, sc->map_update_cmd);
1290
1291 dcmd = &cm->cm_frame->dcmd;
1292 dcmd->header.flags = MFI_FRAME_DIR_NONE;
1293 cm->cm_flags = MFI_CMD_POLLED;
1294 cm->cm_data = NULL;
1295
1296 if ((error = mfi_mapcmd(sc, cm)) != 0) {
1297 device_printf(sc->mfi_dev, "Failed to shutdown controller\n");
1298 }
1299
1300 mfi_release_command(cm);
1301 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1302 return (error);
1303 }
1304
1305 static void
1306 mfi_syspdprobe(struct mfi_softc *sc)
1307 {
1308 struct mfi_frame_header *hdr;
1309 struct mfi_command *cm = NULL;
1310 struct mfi_pd_list *pdlist = NULL;
1311 struct mfi_system_pd *syspd, *tmp;
1312 int error, i, found;
1313
1314 mfi_lockassert(&sc->mfi_config_lock);
1315 mfi_lockassert(&sc->mfi_io_lock);
1316 /* Add SYSTEM PD's */
1317 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_PD_LIST_QUERY,
1318 (void **)&pdlist, sizeof(*pdlist));
1319 if (error) {
1320 device_printf(sc->mfi_dev,
1321 "Error while forming SYSTEM PD list\n");
1322 goto out;
1323 }
1324
1325 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED;
1326 cm->cm_frame->dcmd.mbox[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST;
1327 cm->cm_frame->dcmd.mbox[1] = 0;
1328 if (mfi_mapcmd(sc, cm) != 0) {
1329 device_printf(sc->mfi_dev,
1330 "Failed to get syspd device listing\n");
1331 goto out;
1332 }
1333 bus_dmamap_sync(sc->mfi_buffer_dmat,cm->cm_dmamap,
1334 BUS_DMASYNC_POSTREAD);
1335 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
1336 hdr = &cm->cm_frame->header;
1337 if (hdr->cmd_status != MFI_STAT_OK) {
1338 device_printf(sc->mfi_dev,
1339 "MFI_DCMD_PD_LIST_QUERY failed %x\n", hdr->cmd_status);
1340 goto out;
1341 }
1342 /* Get each PD and add it to the system */
1343 for (i = 0; i < pdlist->count; i++) {
1344 if (pdlist->addr[i].device_id ==
1345 pdlist->addr[i].encl_device_id)
1346 continue;
1347 found = 0;
1348 TAILQ_FOREACH(syspd, &sc->mfi_syspd_tqh, pd_link) {
1349 if (syspd->pd_id == pdlist->addr[i].device_id)
1350 found = 1;
1351 }
1352 if (found == 0)
1353 mfi_add_sys_pd(sc, pdlist->addr[i].device_id);
1354 }
1355 /* Delete SYSPD's whose state has been changed */
1356 TAILQ_FOREACH_MUTABLE(syspd, &sc->mfi_syspd_tqh, pd_link, tmp) {
1357 found = 0;
1358 for (i = 0; i < pdlist->count; i++) {
1359 if (syspd->pd_id == pdlist->addr[i].device_id)
1360 found = 1;
1361 }
1362 if (found == 0) {
1363 kprintf("DELETE\n");
1364 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1365 get_mplock();
1366 device_delete_child(sc->mfi_dev, syspd->pd_dev);
1367 rel_mplock();
1368 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1369 }
1370 }
1371 out:
1372 if (pdlist)
1373 kfree(pdlist, M_MFIBUF);
1374 if (cm)
1375 mfi_release_command(cm);
1376 }
1377
1378 static void
1379 mfi_ldprobe(struct mfi_softc *sc)
1380 {
1381 struct mfi_frame_header *hdr;
1382 struct mfi_command *cm = NULL;
1383 struct mfi_ld_list *list = NULL;
1384 struct mfi_disk *ld;
1385 int error, i;
1386
1387 mfi_lockassert(&sc->mfi_config_lock);
1388 mfi_lockassert(&sc->mfi_io_lock);
1389
1390 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_LD_GET_LIST,
1391 (void **)&list, sizeof(*list));
1392 if (error)
1393 goto out;
1394
1395 cm->cm_flags = MFI_CMD_DATAIN;
1396 if (mfi_wait_command(sc, cm) != 0) {
1397 device_printf(sc->mfi_dev, "Failed to get device listing\n");
1398 goto out;
1399 }
1400
1401 hdr = &cm->cm_frame->header;
1402 if (hdr->cmd_status != MFI_STAT_OK) {
1403 device_printf(sc->mfi_dev, "MFI_DCMD_LD_GET_LIST failed %x\n",
1404 hdr->cmd_status);
1405 goto out;
1406 }
1407
1408 for (i = 0; i < list->ld_count; i++) {
1409 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
1410 if (ld->ld_id == list->ld_list[i].ld.v.target_id)
1411 goto skip_add;
1412 }
1413 mfi_add_ld(sc, list->ld_list[i].ld.v.target_id);
1414 skip_add:;
1415 }
1416 out:
1417 if (list)
1418 kfree(list, M_MFIBUF);
1419 if (cm)
1420 mfi_release_command(cm);
1421
1422 return;
1423 }
1424
1425 /*
1426 * The timestamp is the number of seconds since 00:00 Jan 1, 2000. If
1427 * the bits in 24-31 are all set, then it is the number of seconds since
1428 * boot.
1429 */
1430 static const char *
1431 format_timestamp(uint32_t timestamp)
1432 {
1433 static char buffer[32];
1434
1435 if ((timestamp & 0xff000000) == 0xff000000)
1436 ksnprintf(buffer, sizeof(buffer), "boot + %us", timestamp &
1437 0x00ffffff);
1438 else
1439 ksnprintf(buffer, sizeof(buffer), "%us", timestamp);
1440 return (buffer);
1441 }
1442
1443 static const char *
1444 format_class(int8_t class)
1445 {
1446 static char buffer[6];
1447
1448 switch (class) {
1449 case MFI_EVT_CLASS_DEBUG:
1450 return ("debug");
1451 case MFI_EVT_CLASS_PROGRESS:
1452 return ("progress");
1453 case MFI_EVT_CLASS_INFO:
1454 return ("info");
1455 case MFI_EVT_CLASS_WARNING:
1456 return ("WARN");
1457 case MFI_EVT_CLASS_CRITICAL:
1458 return ("CRIT");
1459 case MFI_EVT_CLASS_FATAL:
1460 return ("FATAL");
1461 case MFI_EVT_CLASS_DEAD:
1462 return ("DEAD");
1463 default:
1464 ksnprintf(buffer, sizeof(buffer), "%d", class);
1465 return (buffer);
1466 }
1467 }
1468
1469 static void
1470 mfi_decode_evt(struct mfi_softc *sc, struct mfi_evt_detail *detail)
1471 {
1472 struct mfi_system_pd *syspd = NULL;
1473
1474 device_printf(sc->mfi_dev, "%d (%s/0x%04x/%s) - %s\n", detail->seq,
1475 format_timestamp(detail->time), detail->evt_class.members.locale,
1476 format_class(detail->evt_class.members.evt_class),
1477 detail->description);
1478
1479 /* Don't act on old AEN's or while shutting down */
1480 if (detail->seq < sc->mfi_boot_seq_num || sc->mfi_detaching)
1481 return;
1482
1483 switch (detail->arg_type) {
1484 case MR_EVT_ARGS_NONE:
1485 if (detail->code == MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED) {
1486 device_printf(sc->mfi_dev, "HostBus scan raised\n");
1487 if (mfi_detect_jbod_change) {
1488 /*
1489 * Probe for new SYSPD's and Delete
1490 * invalid SYSPD's
1491 */
1492 lockmgr(&sc->mfi_config_lock, LK_EXCLUSIVE);
1493 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1494 mfi_syspdprobe(sc);
1495 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1496 lockmgr(&sc->mfi_config_lock, LK_RELEASE);
1497 }
1498 }
1499 break;
1500 case MR_EVT_ARGS_LD_STATE:
1501 /*
1502 * During load time driver reads all the events starting
1503 * from the one that has been logged after shutdown. Avoid
1504 * these old events.
1505 */
1506 if (detail->args.ld_state.new_state == MFI_LD_STATE_OFFLINE ) {
1507 /* Remove the LD */
1508 struct mfi_disk *ld;
1509 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
1510 if (ld->ld_id ==
1511 detail->args.ld_state.ld.target_id)
1512 break;
1513 }
1514 /*
1515 Fix: for kernel panics when SSCD is removed
1516 KASSERT(ld != NULL, ("volume dissappeared"));
1517 */
1518 if (ld != NULL) {
1519 get_mplock();
1520 device_delete_child(sc->mfi_dev, ld->ld_dev);
1521 rel_mplock();
1522 }
1523 }
1524 break;
1525 case MR_EVT_ARGS_PD:
1526 if (detail->code == MR_EVT_PD_REMOVED) {
1527 if (mfi_detect_jbod_change) {
1528 /*
1529 * If the removed device is a SYSPD then
1530 * delete it
1531 */
1532 TAILQ_FOREACH(syspd, &sc->mfi_syspd_tqh,
1533 pd_link) {
1534 if (syspd->pd_id ==
1535 detail->args.pd.device_id) {
1536 get_mplock();
1537 device_delete_child(
1538 sc->mfi_dev,
1539 syspd->pd_dev);
1540 rel_mplock();
1541 break;
1542 }
1543 }
1544 }
1545 }
1546 if (detail->code == MR_EVT_PD_INSERTED) {
1547 if (mfi_detect_jbod_change) {
1548 /* Probe for new SYSPD's */
1549 lockmgr(&sc->mfi_config_lock, LK_EXCLUSIVE);
1550 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1551 mfi_syspdprobe(sc);
1552 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1553 lockmgr(&sc->mfi_config_lock, LK_RELEASE);
1554 }
1555 }
1556 break;
1557 }
1558 }
1559
1560 static void
1561 mfi_queue_evt(struct mfi_softc *sc, struct mfi_evt_detail *detail)
1562 {
1563 struct mfi_evt_queue_elm *elm;
1564
1565 mfi_lockassert(&sc->mfi_io_lock);
1566 elm = kmalloc(sizeof(*elm), M_MFIBUF, M_NOWAIT | M_ZERO);
1567 if (elm == NULL)
1568 return;
1569 memcpy(&elm->detail, detail, sizeof(*detail));
1570 TAILQ_INSERT_TAIL(&sc->mfi_evt_queue, elm, link);
1571 taskqueue_enqueue(taskqueue_swi, &sc->mfi_evt_task);
1572 }
1573
1574 static void
1575 mfi_handle_evt(void *context, int pending)
1576 {
1577 TAILQ_HEAD(,mfi_evt_queue_elm) queue;
1578 struct mfi_softc *sc;
1579 struct mfi_evt_queue_elm *elm;
1580
1581 sc = context;
1582 TAILQ_INIT(&queue);
1583 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1584 TAILQ_CONCAT(&queue, &sc->mfi_evt_queue, link);
1585 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1586 while ((elm = TAILQ_FIRST(&queue)) != NULL) {
1587 TAILQ_REMOVE(&queue, elm, link);
1588 mfi_decode_evt(sc, &elm->detail);
1589 kfree(elm, M_MFIBUF);
1590 }
1591 }
1592
1593 static int
1594 mfi_aen_register(struct mfi_softc *sc, int seq, int locale)
1595 {
1596 struct mfi_command *cm;
1597 struct mfi_dcmd_frame *dcmd;
1598 union mfi_evt current_aen, prior_aen;
1599 struct mfi_evt_detail *ed = NULL;
1600 int error = 0;
1601
1602 current_aen.word = locale;
1603 if (sc->mfi_aen_cm != NULL) {
1604 prior_aen.word =
1605 ((uint32_t *)&sc->mfi_aen_cm->cm_frame->dcmd.mbox)[1];
1606 if (prior_aen.members.evt_class <= current_aen.members.evt_class &&
1607 !((prior_aen.members.locale & current_aen.members.locale)
1608 ^current_aen.members.locale)) {
1609 return (0);
1610 } else {
1611 prior_aen.members.locale |= current_aen.members.locale;
1612 if (prior_aen.members.evt_class
1613 < current_aen.members.evt_class)
1614 current_aen.members.evt_class =
1615 prior_aen.members.evt_class;
1616 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1617 mfi_abort(sc, sc->mfi_aen_cm);
1618 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1619 }
1620 }
1621
1622 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1623 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_EVENT_WAIT,
1624 (void **)&ed, sizeof(*ed));
1625 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1626 if (error) {
1627 goto out;
1628 }
1629
1630 dcmd = &cm->cm_frame->dcmd;
1631 ((uint32_t *)&dcmd->mbox)[0] = seq;
1632 ((uint32_t *)&dcmd->mbox)[1] = locale;
1633 cm->cm_flags = MFI_CMD_DATAIN;
1634 cm->cm_complete = mfi_aen_complete;
1635
1636 sc->last_seq_num = seq;
1637 sc->mfi_aen_cm = cm;
1638
1639 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1640 mfi_enqueue_ready(cm);
1641 mfi_startio(sc);
1642 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1643
1644 out:
1645 return (error);
1646 }
1647
1648 static void
1649 mfi_aen_complete(struct mfi_command *cm)
1650 {
1651 struct mfi_frame_header *hdr;
1652 struct mfi_softc *sc;
1653 struct mfi_evt_detail *detail;
1654 struct mfi_aen *mfi_aen_entry, *tmp;
1655 int seq = 0, aborted = 0;
1656
1657 sc = cm->cm_sc;
1658 mfi_lockassert(&sc->mfi_io_lock);
1659
1660 hdr = &cm->cm_frame->header;
1661
1662 if (sc->mfi_aen_cm == NULL)
1663 return;
1664
1665 if (sc->mfi_aen_cm->cm_aen_abort ||
1666 hdr->cmd_status == MFI_STAT_INVALID_STATUS) {
1667 sc->mfi_aen_cm->cm_aen_abort = 0;
1668 aborted = 1;
1669 } else {
1670 sc->mfi_aen_triggered = 1;
1671 if (sc->mfi_poll_waiting) {
1672 sc->mfi_poll_waiting = 0;
1673 KNOTE(&sc->mfi_kq.ki_note, 0);
1674 }
1675 detail = cm->cm_data;
1676 mfi_queue_evt(sc, detail);
1677 seq = detail->seq + 1;
1678 TAILQ_FOREACH_MUTABLE(mfi_aen_entry, &sc->mfi_aen_pids,
1679 aen_link, tmp) {
1680 TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry,
1681 aen_link);
1682 lwkt_gettoken(&proc_token);
1683 ksignal(mfi_aen_entry->p, SIGIO);
1684 lwkt_reltoken(&proc_token);
1685 kfree(mfi_aen_entry, M_MFIBUF);
1686 }
1687 }
1688
1689 kfree(cm->cm_data, M_MFIBUF);
1690 sc->mfi_aen_cm = NULL;
1691 wakeup(&sc->mfi_aen_cm);
1692 mfi_release_command(cm);
1693
1694 /* set it up again so the driver can catch more events */
1695 if (!aborted) {
1696 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1697 mfi_aen_setup(sc, seq);
1698 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1699 }
1700 }
1701
1702 #define MAX_EVENTS 15
1703
1704 static int
1705 mfi_parse_entries(struct mfi_softc *sc, int start_seq, int stop_seq)
1706 {
1707 struct mfi_command *cm;
1708 struct mfi_dcmd_frame *dcmd;
1709 struct mfi_evt_list *el;
1710 union mfi_evt class_locale;
1711 int error, i, seq, size;
1712
1713 class_locale.members.reserved = 0;
1714 class_locale.members.locale = mfi_event_locale;
1715 class_locale.members.evt_class = mfi_event_class;
1716
1717 size = sizeof(struct mfi_evt_list) + sizeof(struct mfi_evt_detail)
1718 * (MAX_EVENTS - 1);
1719 el = kmalloc(size, M_MFIBUF, M_NOWAIT | M_ZERO);
1720 if (el == NULL)
1721 return (ENOMEM);
1722
1723 for (seq = start_seq;;) {
1724 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1725 if ((cm = mfi_dequeue_free(sc)) == NULL) {
1726 kfree(el, M_MFIBUF);
1727 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1728 return (EBUSY);
1729 }
1730
1731 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1732
1733 dcmd = &cm->cm_frame->dcmd;
1734 bzero(dcmd->mbox, MFI_MBOX_SIZE);
1735 dcmd->header.cmd = MFI_CMD_DCMD;
1736 dcmd->header.timeout = 0;
1737 dcmd->header.data_len = size;
1738 dcmd->opcode = MFI_DCMD_CTRL_EVENT_GET;
1739 ((uint32_t *)&dcmd->mbox)[0] = seq;
1740 ((uint32_t *)&dcmd->mbox)[1] = class_locale.word;
1741 cm->cm_sg = &dcmd->sgl;
1742 cm->cm_total_frame_size = MFI_DCMD_FRAME_SIZE;
1743 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED;
1744 cm->cm_data = el;
1745 cm->cm_len = size;
1746
1747 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1748 if ((error = mfi_mapcmd(sc, cm)) != 0) {
1749 device_printf(sc->mfi_dev,
1750 "Failed to get controller entries\n");
1751 mfi_release_command(cm);
1752 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1753 break;
1754 }
1755
1756 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1757 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
1758 BUS_DMASYNC_POSTREAD);
1759 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
1760
1761 if (dcmd->header.cmd_status == MFI_STAT_NOT_FOUND) {
1762 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1763 mfi_release_command(cm);
1764 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1765 break;
1766 }
1767 if (dcmd->header.cmd_status != MFI_STAT_OK) {
1768 device_printf(sc->mfi_dev,
1769 "Error %d fetching controller entries\n",
1770 dcmd->header.cmd_status);
1771 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1772 mfi_release_command(cm);
1773 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1774 break;
1775 }
1776 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1777 mfi_release_command(cm);
1778 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1779
1780 for (i = 0; i < el->count; i++) {
1781 /*
1782 * If this event is newer than 'stop_seq' then
1783 * break out of the loop. Note that the log
1784 * is a circular buffer so we have to handle
1785 * the case that our stop point is earlier in
1786 * the buffer than our start point.
1787 */
1788 if (el->event[i].seq >= stop_seq) {
1789 if (start_seq <= stop_seq)
1790 break;
1791 else if (el->event[i].seq < start_seq)
1792 break;
1793 }
1794 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1795 mfi_queue_evt(sc, &el->event[i]);
1796 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1797 }
1798 seq = el->event[el->count - 1].seq + 1;
1799 }
1800
1801 kfree(el, M_MFIBUF);
1802 return (0);
1803 }
1804
1805 static int
1806 mfi_add_ld(struct mfi_softc *sc, int id)
1807 {
1808 struct mfi_command *cm;
1809 struct mfi_dcmd_frame *dcmd = NULL;
1810 struct mfi_ld_info *ld_info = NULL;
1811 int error;
1812
1813 mfi_lockassert(&sc->mfi_io_lock);
1814
1815 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_LD_GET_INFO,
1816 (void **)&ld_info, sizeof(*ld_info));
1817 if (error) {
1818 device_printf(sc->mfi_dev,
1819 "Failed to allocate for MFI_DCMD_LD_GET_INFO %d\n", error);
1820 if (ld_info)
1821 kfree(ld_info, M_MFIBUF);
1822 return (error);
1823 }
1824 cm->cm_flags = MFI_CMD_DATAIN;
1825 dcmd = &cm->cm_frame->dcmd;
1826 dcmd->mbox[0] = id;
1827 if (mfi_wait_command(sc, cm) != 0) {
1828 device_printf(sc->mfi_dev,
1829 "Failed to get logical drive: %d\n", id);
1830 kfree(ld_info, M_MFIBUF);
1831 return (0);
1832 }
1833 if (ld_info->ld_config.params.isSSCD != 1) {
1834 mfi_add_ld_complete(cm);
1835 } else {
1836 mfi_release_command(cm);
1837 if (ld_info) /* SSCD drives ld_info free here */
1838 kfree(ld_info, M_MFIBUF);
1839 }
1840 return (0);
1841 }
1842
1843 static void
1844 mfi_add_ld_complete(struct mfi_command *cm)
1845 {
1846 struct mfi_frame_header *hdr;
1847 struct mfi_ld_info *ld_info;
1848 struct mfi_softc *sc;
1849 device_t child;
1850
1851 sc = cm->cm_sc;
1852 hdr = &cm->cm_frame->header;
1853 ld_info = cm->cm_private;
1854
1855 if (hdr->cmd_status != MFI_STAT_OK) {
1856 kfree(ld_info, M_MFIBUF);
1857 mfi_release_command(cm);
1858 return;
1859 }
1860 mfi_release_command(cm);
1861
1862 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1863 get_mplock();
1864 if ((child = device_add_child(sc->mfi_dev, "mfid", -1)) == NULL) {
1865 device_printf(sc->mfi_dev, "Failed to add logical disk\n");
1866 kfree(ld_info, M_MFIBUF);
1867 rel_mplock();
1868 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1869 return;
1870 }
1871
1872 device_set_ivars(child, ld_info);
1873 device_set_desc(child, "MFI Logical Disk");
1874 bus_generic_attach(sc->mfi_dev);
1875 rel_mplock();
1876 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1877 }
1878
1879 static int
1880 mfi_add_sys_pd(struct mfi_softc *sc, int id)
1881 {
1882 struct mfi_command *cm;
1883 struct mfi_dcmd_frame *dcmd = NULL;
1884 struct mfi_pd_info *pd_info = NULL;
1885 int error;
1886
1887 mfi_lockassert(&sc->mfi_io_lock);
1888
1889 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_PD_GET_INFO,
1890 (void **)&pd_info, sizeof(*pd_info));
1891 if (error) {
1892 device_printf(sc->mfi_dev,
1893 "Failed to allocated for MFI_DCMD_PD_GET_INFO %d\n",
1894 error);
1895 if (pd_info)
1896 kfree(pd_info, M_MFIBUF);
1897 return (error);
1898 }
1899 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED;
1900 dcmd = &cm->cm_frame->dcmd;
1901 dcmd->mbox[0] = id;
1902 dcmd->header.scsi_status = 0;
1903 dcmd->header.pad0 = 0;
1904 if (mfi_mapcmd(sc, cm) != 0) {
1905 device_printf(sc->mfi_dev,
1906 "Failed to get physical drive info %d\n", id);
1907 kfree(pd_info, M_MFIBUF);
1908 return (0);
1909 }
1910 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
1911 BUS_DMASYNC_POSTREAD);
1912 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
1913 mfi_add_sys_pd_complete(cm);
1914 return (0);
1915 }
1916
1917 static void
1918 mfi_add_sys_pd_complete(struct mfi_command *cm)
1919 {
1920 struct mfi_frame_header *hdr;
1921 struct mfi_pd_info *pd_info;
1922 struct mfi_softc *sc;
1923 device_t child;
1924
1925 sc = cm->cm_sc;
1926 hdr = &cm->cm_frame->header;
1927 pd_info = cm->cm_private;
1928
1929 if (hdr->cmd_status != MFI_STAT_OK) {
1930 kfree(pd_info, M_MFIBUF);
1931 mfi_release_command(cm);
1932 return;
1933 }
1934 if (pd_info->fw_state != MFI_PD_STATE_SYSTEM) {
1935 device_printf(sc->mfi_dev, "PD=%x is not SYSTEM PD\n",
1936 pd_info->ref.v.device_id);
1937 kfree(pd_info, M_MFIBUF);
1938 mfi_release_command(cm);
1939 return;
1940 }
1941 mfi_release_command(cm);
1942
1943 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
1944 get_mplock();
1945 if ((child = device_add_child(sc->mfi_dev, "mfisyspd", -1)) == NULL) {
1946 device_printf(sc->mfi_dev, "Failed to add system pd\n");
1947 kfree(pd_info, M_MFIBUF);
1948 rel_mplock();
1949 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1950 return;
1951 }
1952
1953 device_set_ivars(child, pd_info);
1954 device_set_desc(child, "MFI System PD");
1955 bus_generic_attach(sc->mfi_dev);
1956 rel_mplock();
1957 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
1958 }
1959
1960 static struct mfi_command *
1961 mfi_bio_command(struct mfi_softc *sc)
1962 {
1963 struct bio *bio;
1964 struct mfi_command *cm = NULL;
1965 struct mfi_disk *mfid;
1966
1967 /* reserving two commands to avoid starvation for IOCTL */
1968 if (sc->mfi_qstat[MFIQ_FREE].q_length < 2)
1969 return (NULL);
1970 if ((bio = mfi_dequeue_bio(sc)) == NULL)
1971 return (NULL);
1972 mfid = bio->bio_driver_info;
1973 if (mfid->ld_flags & MFI_DISK_FLAGS_SYSPD)
1974 cm = mfi_build_syspdio(sc, bio);
1975 else
1976 cm = mfi_build_ldio(sc, bio);
1977 if (!cm)
1978 mfi_enqueue_bio(sc, bio);
1979 return cm;
1980 }
1981
1982 static struct mfi_command *
1983 mfi_build_syspdio(struct mfi_softc *sc, struct bio *bio)
1984 {
1985 struct mfi_command *cm;
1986 struct buf *bp;
1987 struct mfi_system_pd *disk;
1988 struct mfi_pass_frame *pass;
1989 int flags = 0, blkcount = 0;
1990 uint32_t context = 0;
1991
1992 if ((cm = mfi_dequeue_free(sc)) == NULL)
1993 return (NULL);
1994
1995 /* Zero out the MFI frame */
1996 context = cm->cm_frame->header.context;
1997 bzero(cm->cm_frame, sizeof(union mfi_frame));
1998 cm->cm_frame->header.context = context;
1999 bp = bio->bio_buf;
2000 pass = &cm->cm_frame->pass;
2001 bzero(pass->cdb, 16);
2002 pass->header.cmd = MFI_CMD_PD_SCSI_IO;
2003 switch (bp->b_cmd & 0x03) {
2004 case BUF_CMD_READ:
2005 pass->cdb[0] = READ_10;
2006 flags = MFI_CMD_DATAIN;
2007 break;
2008 case BUF_CMD_WRITE:
2009 pass->cdb[0] = WRITE_10;
2010 flags = MFI_CMD_DATAOUT;
2011 break;
2012 default:
2013 panic("Invalid bio command");
2014 }
2015
2016 /* Cheat with the sector length to avoid a non-constant division */
2017 blkcount = (bp->b_bcount + MFI_SECTOR_LEN - 1) / MFI_SECTOR_LEN;
2018 disk = bio->bio_driver_info;
2019 /* Fill the LBA and Transfer length in CDB */
2020 pass->cdb[2] = ((bio->bio_offset / MFI_SECTOR_LEN) & 0xff000000) >> 24;
2021 pass->cdb[3] = ((bio->bio_offset / MFI_SECTOR_LEN) & 0x00ff0000) >> 16;
2022 pass->cdb[4] = ((bio->bio_offset / MFI_SECTOR_LEN) & 0x0000ff00) >> 8;
2023 pass->cdb[5] = (bio->bio_offset / MFI_SECTOR_LEN) & 0x000000ff;
2024 pass->cdb[7] = (blkcount & 0xff00) >> 8;
2025 pass->cdb[8] = (blkcount & 0x00ff);
2026 pass->header.target_id = disk->pd_id;
2027 pass->header.timeout = 0;
2028 pass->header.flags = 0;
2029 pass->header.scsi_status = 0;
2030 pass->header.sense_len = MFI_SENSE_LEN;
2031 pass->header.data_len = bp->b_bcount;
2032 pass->header.cdb_len = 10;
2033 pass->sense_addr_lo = (uint32_t)cm->cm_sense_busaddr;
2034 pass->sense_addr_hi = (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32);
2035 cm->cm_complete = mfi_bio_complete;
2036 cm->cm_private = bio;
2037 cm->cm_data = bp->b_data;
2038 cm->cm_len = bp->b_bcount;
2039 cm->cm_sg = &pass->sgl;
2040 cm->cm_total_frame_size = MFI_PASS_FRAME_SIZE;
2041 cm->cm_flags = flags;
2042 return (cm);
2043 }
2044
2045 static struct mfi_command *
2046 mfi_build_ldio(struct mfi_softc *sc, struct bio *bio)
2047 {
2048 struct mfi_io_frame *io;
2049 struct buf *bp;
2050 struct mfi_disk *disk;
2051 struct mfi_command *cm;
2052 int flags, blkcount;
2053 uint32_t context = 0;
2054
2055 if ((cm = mfi_dequeue_free(sc)) == NULL)
2056 return (NULL);
2057
2058 /* Zero out the MFI frame */
2059 context = cm->cm_frame->header.context;
2060 bzero(cm->cm_frame, sizeof(union mfi_frame));
2061 cm->cm_frame->header.context = context;
2062 bp = bio->bio_buf;
2063 io = &cm->cm_frame->io;
2064 switch (bp->b_cmd & 0x03) {
2065 case BUF_CMD_READ:
2066 io->header.cmd = MFI_CMD_LD_READ;
2067 flags = MFI_CMD_DATAIN;
2068 break;
2069 case BUF_CMD_WRITE:
2070 io->header.cmd = MFI_CMD_LD_WRITE;
2071 flags = MFI_CMD_DATAOUT;
2072 break;
2073 default:
2074 panic("Invalid bio command");
2075 }
2076
2077 /* Cheat with the sector length to avoid a non-constant division */
2078 blkcount = (bp->b_bcount + MFI_SECTOR_LEN - 1) / MFI_SECTOR_LEN;
2079 disk = bio->bio_driver_info;
2080 io->header.target_id = disk->ld_id;
2081 io->header.timeout = 0;
2082 io->header.flags = 0;
2083 io->header.scsi_status = 0;
2084 io->header.sense_len = MFI_SENSE_LEN;
2085 io->header.data_len = blkcount;
2086 io->sense_addr_lo = (uint32_t)cm->cm_sense_busaddr;
2087 io->sense_addr_hi = (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32);
2088 io->lba_hi = ((bio->bio_offset / MFI_SECTOR_LEN) & 0xffffffff00000000) >> 32;
2089 io->lba_lo = (bio->bio_offset / MFI_SECTOR_LEN) & 0xffffffff;
2090 cm->cm_complete = mfi_bio_complete;
2091 cm->cm_private = bio;
2092 cm->cm_data = bp->b_data;
2093 cm->cm_len = bp->b_bcount;
2094 cm->cm_sg = &io->sgl;
2095 cm->cm_total_frame_size = MFI_IO_FRAME_SIZE;
2096 cm->cm_flags = flags;
2097 return (cm);
2098 }
2099
2100 static void
2101 mfi_bio_complete(struct mfi_command *cm)
2102 {
2103 struct bio *bio;
2104 struct buf *bp;
2105 struct mfi_frame_header *hdr;
2106 struct mfi_softc *sc;
2107
2108 bio = cm->cm_private;
2109 bp = bio->bio_buf;
2110 hdr = &cm->cm_frame->header;
2111 sc = cm->cm_sc;
2112
2113 if ((hdr->cmd_status != MFI_STAT_OK) || (hdr->scsi_status != 0)) {
2114 bp->b_flags |= B_ERROR;
2115 bp->b_error = EIO;
2116 device_printf(sc->mfi_dev, "I/O error, status= %d "
2117 "scsi_status= %d\n", hdr->cmd_status, hdr->scsi_status);
2118 mfi_print_sense(cm->cm_sc, cm->cm_sense);
2119 } else if (cm->cm_error != 0) {
2120 bp->b_flags |= B_ERROR;
2121 }
2122
2123 mfi_release_command(cm);
2124 mfi_disk_complete(bio);
2125 }
2126
2127 void
2128 mfi_startio(struct mfi_softc *sc)
2129 {
2130 struct mfi_command *cm;
2131 struct ccb_hdr *ccbh;
2132
2133 for (;;) {
2134 /* Don't bother if we're short on resources */
2135 if (sc->mfi_flags & MFI_FLAGS_QFRZN)
2136 break;
2137
2138 /* Try a command that has already been prepared */
2139 cm = mfi_dequeue_ready(sc);
2140
2141 if (cm == NULL) {
2142 if ((ccbh = TAILQ_FIRST(&sc->mfi_cam_ccbq)) != NULL)
2143 cm = sc->mfi_cam_start(ccbh);
2144 }
2145
2146 /* Nope, so look for work on the bioq */
2147 if (cm == NULL)
2148 cm = mfi_bio_command(sc);
2149
2150 /* No work available, so exit */
2151 if (cm == NULL)
2152 break;
2153
2154 /* Send the command to the controller */
2155 if (mfi_mapcmd(sc, cm) != 0) {
2156 mfi_requeue_ready(cm);
2157 break;
2158 }
2159 }
2160 }
2161
2162 int
2163 mfi_mapcmd(struct mfi_softc *sc, struct mfi_command *cm)
2164 {
2165 int error, polled;
2166
2167 mfi_lockassert(&sc->mfi_io_lock);
2168
2169 if ((cm->cm_data != NULL) && (cm->cm_frame->header.cmd != MFI_CMD_STP)) {
2170 polled = (cm->cm_flags & MFI_CMD_POLLED) ? BUS_DMA_NOWAIT : 0;
2171 error = bus_dmamap_load(sc->mfi_buffer_dmat, cm->cm_dmamap,
2172 cm->cm_data, cm->cm_len, mfi_data_cb, cm, polled);
2173 if (error == EINPROGRESS) {
2174 sc->mfi_flags |= MFI_FLAGS_QFRZN;
2175 return (0);
2176 }
2177 } else {
2178 if (sc->MFA_enabled)
2179 error = mfi_tbolt_send_frame(sc, cm);
2180 else
2181 error = mfi_send_frame(sc, cm);
2182 }
2183
2184 return (error);
2185 }
2186
2187 static void
2188 mfi_data_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
2189 {
2190 struct mfi_frame_header *hdr;
2191 struct mfi_command *cm;
2192 union mfi_sgl *sgl;
2193 struct mfi_softc *sc;
2194 int i, j, first, dir;
2195
2196 cm = (struct mfi_command *)arg;
2197 sc = cm->cm_sc;
2198 hdr = &cm->cm_frame->header;
2199 sgl = cm->cm_sg;
2200
2201 if (error) {
2202 kprintf("error %d in callback\n", error);
2203 cm->cm_error = error;
2204 mfi_complete(sc, cm);
2205 return;
2206 }
2207
2208 /* Use IEEE sgl only for IO's on a SKINNY controller
2209 * For other commands on a SKINNY controller use either
2210 * sg32 or sg64 based on the sizeof(bus_addr_t).
2211 * Also calculate the total frame size based on the type
2212 * of SGL used.
2213 */
2214 if (((cm->cm_frame->header.cmd == MFI_CMD_PD_SCSI_IO) ||
2215 (cm->cm_frame->header.cmd == MFI_CMD_LD_READ) ||
2216 (cm->cm_frame->header.cmd == MFI_CMD_LD_WRITE)) &&
2217 (sc->mfi_flags & MFI_FLAGS_SKINNY)) {
2218 for (i = 0; i < nsegs; i++) {
2219 sgl->sg_skinny[i].addr = segs[i].ds_addr;
2220 sgl->sg_skinny[i].len = segs[i].ds_len;
2221 sgl->sg_skinny[i].flag = 0;
2222 }
2223 hdr->flags |= MFI_FRAME_IEEE_SGL | MFI_FRAME_SGL64;
2224 hdr->sg_count = nsegs;
2225 } else {
2226 j = 0;
2227 if (cm->cm_frame->header.cmd == MFI_CMD_STP) {
2228 first = cm->cm_stp_len;
2229 if ((sc->mfi_flags & MFI_FLAGS_SG64) == 0) {
2230 sgl->sg32[j].addr = segs[0].ds_addr;
2231 sgl->sg32[j++].len = first;
2232 } else {
2233 sgl->sg64[j].addr = segs[0].ds_addr;
2234 sgl->sg64[j++].len = first;
2235 }
2236 } else
2237 first = 0;
2238 if ((sc->mfi_flags & MFI_FLAGS_SG64) == 0) {
2239 for (i = 0; i < nsegs; i++) {
2240 sgl->sg32[j].addr = segs[i].ds_addr + first;
2241 sgl->sg32[j++].len = segs[i].ds_len - first;
2242 first = 0;
2243 }
2244 } else {
2245 for (i = 0; i < nsegs; i++) {
2246 sgl->sg64[j].addr = segs[i].ds_addr + first;
2247 sgl->sg64[j++].len = segs[i].ds_len - first;
2248 first = 0;
2249 }
2250 hdr->flags |= MFI_FRAME_SGL64;
2251 }
2252 hdr->sg_count = j;
2253 }
2254
2255 dir = 0;
2256 if (cm->cm_flags & MFI_CMD_DATAIN) {
2257 dir |= BUS_DMASYNC_PREREAD;
2258 hdr->flags |= MFI_FRAME_DIR_READ;
2259 }
2260 if (cm->cm_flags & MFI_CMD_DATAOUT) {
2261 dir |= BUS_DMASYNC_PREWRITE;
2262 hdr->flags |= MFI_FRAME_DIR_WRITE;
2263 }
2264 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, dir);
2265 cm->cm_flags |= MFI_CMD_MAPPED;
2266
2267 /*
2268 * Instead of calculating the total number of frames in the
2269 * compound frame, it's already assumed that there will be at
2270 * least 1 frame, so don't compensate for the modulo of the
2271 * following division.
2272 */
2273 cm->cm_total_frame_size += (sc->mfi_sge_size * nsegs);
2274 cm->cm_extra_frames = (cm->cm_total_frame_size - 1) / MFI_FRAME_SIZE;
2275
2276 if (sc->MFA_enabled)
2277 mfi_tbolt_send_frame(sc, cm);
2278 else
2279 mfi_send_frame(sc, cm);
2280 }
2281
2282 static int
2283 mfi_send_frame(struct mfi_softc *sc, struct mfi_command *cm)
2284 {
2285 struct mfi_frame_header *hdr;
2286 int tm = MFI_POLL_TIMEOUT_SECS * 1000;
2287
2288 hdr = &cm->cm_frame->header;
2289
2290 if ((cm->cm_flags & MFI_CMD_POLLED) == 0) {
2291 cm->cm_timestamp = time_second;
2292 mfi_enqueue_busy(cm);
2293 } else {
2294 hdr->cmd_status = MFI_STAT_INVALID_STATUS;
2295 hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
2296 }
2297
2298 /*
2299 * The bus address of the command is aligned on a 64 byte boundary,
2300 * leaving the least 6 bits as zero. For whatever reason, the
2301 * hardware wants the address shifted right by three, leaving just
2302 * 3 zero bits. These three bits are then used as a prefetching
2303 * hint for the hardware to predict how many frames need to be
2304 * fetched across the bus. If a command has more than 8 frames
2305 * then the 3 bits are set to 0x7 and the firmware uses other
2306 * information in the command to determine the total amount to fetch.
2307 * However, FreeBSD doesn't support I/O larger than 128K, so 8 frames
2308 * is enough for both 32bit and 64bit systems.
2309 */
2310 if (cm->cm_extra_frames > 7)
2311 cm->cm_extra_frames = 7;
2312
2313 sc->mfi_issue_cmd(sc, cm->cm_frame_busaddr, cm->cm_extra_frames);
2314
2315 if ((cm->cm_flags & MFI_CMD_POLLED) == 0)
2316 return (0);
2317
2318 /* This is a polled command, so busy-wait for it to complete. */
2319 while (hdr->cmd_status == MFI_STAT_INVALID_STATUS) {
2320 DELAY(1000);
2321 tm -= 1;
2322 if (tm <= 0)
2323 break;
2324 }
2325
2326 if (hdr->cmd_status == MFI_STAT_INVALID_STATUS) {
2327 device_printf(sc->mfi_dev, "Frame %p timed out "
2328 "command 0x%X\n", hdr, cm->cm_frame->dcmd.opcode);
2329 return (ETIMEDOUT);
2330 }
2331
2332 return (0);
2333 }
2334
2335 void
2336 mfi_complete(struct mfi_softc *sc, struct mfi_command *cm)
2337 {
2338 int dir;
2339
2340 if ((cm->cm_flags & MFI_CMD_MAPPED) != 0) {
2341 dir = 0;
2342 if ((cm->cm_flags & MFI_CMD_DATAIN) ||
2343 (cm->cm_frame->header.cmd == MFI_CMD_STP))
2344 dir |= BUS_DMASYNC_POSTREAD;
2345 if (cm->cm_flags & MFI_CMD_DATAOUT)
2346 dir |= BUS_DMASYNC_POSTWRITE;
2347
2348 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, dir);
2349 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
2350 cm->cm_flags &= ~MFI_CMD_MAPPED;
2351 }
2352
2353 cm->cm_flags |= MFI_CMD_COMPLETED;
2354
2355 if (cm->cm_complete != NULL)
2356 cm->cm_complete(cm);
2357 else
2358 wakeup(cm);
2359 }
2360
2361 static int
2362 mfi_abort(struct mfi_softc *sc, struct mfi_command *cm_abort)
2363 {
2364 struct mfi_command *cm;
2365 struct mfi_abort_frame *abort;
2366 int i = 0;
2367 uint32_t context = 0;
2368
2369 mfi_lockassert(&sc->mfi_io_lock);
2370
2371 if ((cm = mfi_dequeue_free(sc)) == NULL) {
2372 return (EBUSY);
2373 }
2374
2375 /* Zero out the MFI frame */
2376 context = cm->cm_frame->header.context;
2377 bzero(cm->cm_frame, sizeof(union mfi_frame));
2378 cm->cm_frame->header.context = context;
2379
2380 abort = &cm->cm_frame->abort;
2381 abort->header.cmd = MFI_CMD_ABORT;
2382 abort->header.flags = 0;
2383 abort->header.scsi_status = 0;
2384 abort->abort_context = cm_abort->cm_frame->header.context;
2385 abort->abort_mfi_addr_lo = (uint32_t)cm_abort->cm_frame_busaddr;
2386 abort->abort_mfi_addr_hi =
2387 (uint32_t)((uint64_t)cm_abort->cm_frame_busaddr >> 32);
2388 cm->cm_data = NULL;
2389 cm->cm_flags = MFI_CMD_POLLED;
2390
2391 if (sc->mfi_aen_cm)
2392 sc->mfi_aen_cm->cm_aen_abort = 1;
2393 mfi_mapcmd(sc, cm);
2394 mfi_release_command(cm);
2395
2396 while (i < 5 && sc->mfi_aen_cm != NULL) {
2397 lksleep(&sc->mfi_aen_cm, &sc->mfi_io_lock, 0, "mfiabort",
2398 5 * hz);
2399 i++;
2400 }
2401
2402 return (0);
2403 }
2404
2405 int
2406 mfi_dump_blocks(struct mfi_softc *sc, int id, uint64_t lba, void *virt,
2407 int len)
2408 {
2409 struct mfi_command *cm;
2410 struct mfi_io_frame *io;
2411 int error;
2412 uint32_t context = 0;
2413
2414 if ((cm = mfi_dequeue_free(sc)) == NULL)
2415 return (EBUSY);
2416
2417 /* Zero out the MFI frame */
2418 context = cm->cm_frame->header.context;
2419 bzero(cm->cm_frame, sizeof(union mfi_frame));
2420 cm->cm_frame->header.context = context;
2421
2422 io = &cm->cm_frame->io;
2423 io->header.cmd = MFI_CMD_LD_WRITE;
2424 io->header.target_id = id;
2425 io->header.timeout = 0;
2426 io->header.flags = 0;
2427 io->header.scsi_status = 0;
2428 io->header.sense_len = MFI_SENSE_LEN;
2429 io->header.data_len = (len + MFI_SECTOR_LEN - 1) / MFI_SECTOR_LEN;
2430 io->sense_addr_lo = (uint32_t)cm->cm_sense_busaddr;
2431 io->sense_addr_hi = (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32);
2432 io->lba_hi = (lba & 0xffffffff00000000) >> 32;
2433 io->lba_lo = lba & 0xffffffff;
2434 cm->cm_data = virt;
2435 cm->cm_len = len;
2436 cm->cm_sg = &io->sgl;
2437 cm->cm_total_frame_size = MFI_IO_FRAME_SIZE;
2438 cm->cm_flags = MFI_CMD_POLLED | MFI_CMD_DATAOUT;
2439
2440 error = mfi_mapcmd(sc, cm);
2441 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
2442 BUS_DMASYNC_POSTWRITE);
2443 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
2444 mfi_release_command(cm);
2445
2446 return (error);
2447 }
2448
2449 int
2450 mfi_dump_syspd_blocks(struct mfi_softc *sc, int id, uint64_t lba, void *virt,
2451 int len)
2452 {
2453 struct mfi_command *cm;
2454 struct mfi_pass_frame *pass;
2455 int error;
2456 int blkcount = 0;
2457
2458 if ((cm = mfi_dequeue_free(sc)) == NULL)
2459 return (EBUSY);
2460
2461 pass = &cm->cm_frame->pass;
2462 bzero(pass->cdb, 16);
2463 pass->header.cmd = MFI_CMD_PD_SCSI_IO;
2464 pass->cdb[0] = WRITE_10;
2465 pass->cdb[2] = (lba & 0xff000000) >> 24;
2466 pass->cdb[3] = (lba & 0x00ff0000) >> 16;
2467 pass->cdb[4] = (lba & 0x0000ff00) >> 8;
2468 pass->cdb[5] = (lba & 0x000000ff);
2469 blkcount = (len + MFI_SECTOR_LEN - 1) / MFI_SECTOR_LEN;
2470 pass->cdb[7] = (blkcount & 0xff00) >> 8;
2471 pass->cdb[8] = (blkcount & 0x00ff);
2472 pass->header.target_id = id;
2473 pass->header.timeout = 0;
2474 pass->header.flags = 0;
2475 pass->header.scsi_status = 0;
2476 pass->header.sense_len = MFI_SENSE_LEN;
2477 pass->header.data_len = len;
2478 pass->header.cdb_len = 10;
2479 pass->sense_addr_lo = (uint32_t)cm->cm_sense_busaddr;
2480 pass->sense_addr_hi = (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32);
2481 cm->cm_data = virt;
2482 cm->cm_len = len;
2483 cm->cm_sg = &pass->sgl;
2484 cm->cm_total_frame_size = MFI_PASS_FRAME_SIZE;
2485 cm->cm_flags = MFI_CMD_POLLED | MFI_CMD_DATAOUT;
2486
2487 error = mfi_mapcmd(sc, cm);
2488 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
2489 BUS_DMASYNC_POSTWRITE);
2490 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
2491 mfi_release_command(cm);
2492
2493 return (error);
2494 }
2495
2496 static int
2497 mfi_open(struct dev_open_args *ap)
2498 {
2499 cdev_t dev = ap->a_head.a_dev;
2500 struct mfi_softc *sc;
2501 int error;
2502
2503 sc = dev->si_drv1;
2504
2505 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
2506 if (sc->mfi_detaching)
2507 error = ENXIO;
2508 else {
2509 sc->mfi_flags |= MFI_FLAGS_OPEN;
2510 error = 0;
2511 }
2512 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
2513
2514 return (error);
2515 }
2516
2517 static int
2518 mfi_close(struct dev_close_args *ap)
2519 {
2520 cdev_t dev = ap->a_head.a_dev;
2521 struct mfi_softc *sc;
2522 struct mfi_aen *mfi_aen_entry, *tmp;
2523
2524 sc = dev->si_drv1;
2525
2526 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
2527 sc->mfi_flags &= ~MFI_FLAGS_OPEN;
2528
2529 TAILQ_FOREACH_MUTABLE(mfi_aen_entry, &sc->mfi_aen_pids, aen_link, tmp) {
2530 if (mfi_aen_entry->p == curproc) {
2531 TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry,
2532 aen_link);
2533 kfree(mfi_aen_entry, M_MFIBUF);
2534 }
2535 }
2536 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
2537 return (0);
2538 }
2539
2540 static int
2541 mfi_config_lock(struct mfi_softc *sc, uint32_t opcode)
2542 {
2543
2544 switch (opcode) {
2545 case MFI_DCMD_LD_DELETE:
2546 case MFI_DCMD_CFG_ADD:
2547 case MFI_DCMD_CFG_CLEAR:
2548 lockmgr(&sc->mfi_config_lock, LK_EXCLUSIVE);
2549 return (1);
2550 default:
2551 return (0);
2552 }
2553 }
2554
2555 static void
2556 mfi_config_unlock(struct mfi_softc *sc, int locked)
2557 {
2558
2559 if (locked)
2560 lockmgr(&sc->mfi_config_lock, LK_RELEASE);
2561 }
2562
2563 /*
2564 * Perform pre-issue checks on commands from userland and possibly veto
2565 * them.
2566 */
2567 static int
2568 mfi_check_command_pre(struct mfi_softc *sc, struct mfi_command *cm)
2569 {
2570 struct mfi_disk *ld, *ld2;
2571 int error;
2572 struct mfi_system_pd *syspd = NULL;
2573 uint16_t syspd_id;
2574 uint16_t *mbox;
2575
2576 mfi_lockassert(&sc->mfi_io_lock);
2577 error = 0;
2578 switch (cm->cm_frame->dcmd.opcode) {
2579 case MFI_DCMD_LD_DELETE:
2580 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
2581 if (ld->ld_id == cm->cm_frame->dcmd.mbox[0])
2582 break;
2583 }
2584 if (ld == NULL)
2585 error = ENOENT;
2586 else
2587 error = mfi_disk_disable(ld);
2588 break;
2589 case MFI_DCMD_CFG_CLEAR:
2590 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
2591 error = mfi_disk_disable(ld);
2592 if (error)
2593 break;
2594 }
2595 if (error) {
2596 TAILQ_FOREACH(ld2, &sc->mfi_ld_tqh, ld_link) {
2597 if (ld2 == ld)
2598 break;
2599 mfi_disk_enable(ld2);
2600 }
2601 }
2602 break;
2603 case MFI_DCMD_PD_STATE_SET:
2604 mbox = (uint16_t *)cm->cm_frame->dcmd.mbox;
2605 syspd_id = mbox[0];
2606 if (mbox[2] == MFI_PD_STATE_UNCONFIGURED_GOOD) {
2607 TAILQ_FOREACH(syspd, &sc->mfi_syspd_tqh, pd_link) {
2608 if (syspd->pd_id == syspd_id)
2609 break;
2610 }
2611 } else {
2612 break;
2613 }
2614 if (syspd)
2615 error = mfi_syspd_disable(syspd);
2616 break;
2617 default:
2618 break;
2619 }
2620 return (error);
2621 }
2622
2623 /* Perform post-issue checks on commands from userland. */
2624 static void
2625 mfi_check_command_post(struct mfi_softc *sc, struct mfi_command *cm)
2626 {
2627 struct mfi_disk *ld, *ldn;
2628 struct mfi_system_pd *syspd = NULL;
2629 uint16_t syspd_id;
2630 uint16_t *mbox;
2631
2632 switch (cm->cm_frame->dcmd.opcode) {
2633 case MFI_DCMD_LD_DELETE:
2634 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
2635 if (ld->ld_id == cm->cm_frame->dcmd.mbox[0])
2636 break;
2637 }
2638 KASSERT(ld != NULL, ("volume dissappeared"));
2639 if (cm->cm_frame->header.cmd_status == MFI_STAT_OK) {
2640 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
2641 get_mplock();
2642 device_delete_child(sc->mfi_dev, ld->ld_dev);
2643 rel_mplock();
2644 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
2645 } else
2646 mfi_disk_enable(ld);
2647 break;
2648 case MFI_DCMD_CFG_CLEAR:
2649 if (cm->cm_frame->header.cmd_status == MFI_STAT_OK) {
2650 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
2651 get_mplock();
2652 TAILQ_FOREACH_MUTABLE(ld, &sc->mfi_ld_tqh, ld_link, ldn) {
2653 device_delete_child(sc->mfi_dev, ld->ld_dev);
2654 }
2655 rel_mplock();
2656 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
2657 } else {
2658 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link)
2659 mfi_disk_enable(ld);
2660 }
2661 break;
2662 case MFI_DCMD_CFG_ADD:
2663 mfi_ldprobe(sc);
2664 break;
2665 case MFI_DCMD_CFG_FOREIGN_IMPORT:
2666 mfi_ldprobe(sc);
2667 break;
2668 case MFI_DCMD_PD_STATE_SET:
2669 mbox = (uint16_t *)cm->cm_frame->dcmd.mbox;
2670 syspd_id = mbox[0];
2671 if (mbox[2] == MFI_PD_STATE_UNCONFIGURED_GOOD) {
2672 TAILQ_FOREACH(syspd, &sc->mfi_syspd_tqh, pd_link) {
2673 if (syspd->pd_id == syspd_id)
2674 break;
2675 }
2676 } else {
2677 break;
2678 }
2679 /* If the transition fails then enable the syspd again */
2680 if (syspd && cm->cm_frame->header.cmd_status != MFI_STAT_OK)
2681 mfi_syspd_enable(syspd);
2682 break;
2683 }
2684 }
2685
2686 static int
2687 mfi_check_for_sscd(struct mfi_softc *sc, struct mfi_command *cm)
2688 {
2689 struct mfi_config_data *conf_data = cm->cm_data;
2690 struct mfi_command *ld_cm = NULL;
2691 struct mfi_ld_info *ld_info = NULL;
2692 int error = 0;
2693
2694 if ((cm->cm_frame->dcmd.opcode == MFI_DCMD_CFG_ADD) &&
2695 (conf_data->ld[0].params.isSSCD == 1)) {
2696 error = 1;
2697 } else if (cm->cm_frame->dcmd.opcode == MFI_DCMD_LD_DELETE) {
2698 error = mfi_dcmd_command(sc, &ld_cm, MFI_DCMD_LD_GET_INFO,
2699 (void **)&ld_info, sizeof(*ld_info));
2700 if (error) {
2701 device_printf(sc->mfi_dev, "Failed to allocate"
2702 "MFI_DCMD_LD_GET_INFO %d", error);
2703 if (ld_info)
2704 kfree(ld_info, M_MFIBUF);
2705 return 0;
2706 }
2707 ld_cm->cm_flags = MFI_CMD_DATAIN;
2708 ld_cm->cm_frame->dcmd.mbox[0]= cm->cm_frame->dcmd.mbox[0];
2709 ld_cm->cm_frame->header.target_id = cm->cm_frame->dcmd.mbox[0];
2710 if (mfi_wait_command(sc, ld_cm) != 0) {
2711 device_printf(sc->mfi_dev, "failed to get log drv\n");
2712 mfi_release_command(ld_cm);
2713 kfree(ld_info, M_MFIBUF);
2714 return 0;
2715 }
2716
2717 if (ld_cm->cm_frame->header.cmd_status != MFI_STAT_OK) {
2718 kfree(ld_info, M_MFIBUF);
2719 mfi_release_command(ld_cm);
2720 return 0;
2721 } else {
2722 ld_info = (struct mfi_ld_info *)ld_cm->cm_private;
2723 }
2724
2725 if (ld_info->ld_config.params.isSSCD == 1)
2726 error = 1;
2727
2728 mfi_release_command(ld_cm);
2729 kfree(ld_info, M_MFIBUF);
2730 }
2731 return error;
2732 }
2733
2734 static int
2735 mfi_stp_cmd(struct mfi_softc *sc, struct mfi_command *cm,caddr_t arg)
2736 {
2737 uint8_t i;
2738 struct mfi_ioc_packet *ioc;
2739 ioc = (struct mfi_ioc_packet *)arg;
2740 int sge_size, error;
2741 struct megasas_sge *kern_sge;
2742
2743 memset(sc->kbuff_arr, 0, sizeof(sc->kbuff_arr));
2744 kern_sge =(struct megasas_sge *) ((uintptr_t)cm->cm_frame + ioc->mfi_sgl_off);
2745 cm->cm_frame->header.sg_count = ioc->mfi_sge_count;
2746
2747 if (sizeof(bus_addr_t) == 8) {
2748 cm->cm_frame->header.flags |= MFI_FRAME_SGL64;
2749 cm->cm_extra_frames = 2;
2750 sge_size = sizeof(struct mfi_sg64);
2751 } else {
2752 cm->cm_extra_frames = (cm->cm_total_frame_size - 1) / MFI_FRAME_SIZE;
2753 sge_size = sizeof(struct mfi_sg32);
2754 }
2755
2756 cm->cm_total_frame_size += (sge_size * ioc->mfi_sge_count);
2757 for (i = 0; i < ioc->mfi_sge_count; i++) {
2758 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */
2759 1, 0, /* algnmnt, boundary */
2760 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
2761 BUS_SPACE_MAXADDR, /* highaddr */
2762 NULL, NULL, /* filter, filterarg */
2763 ioc->mfi_sgl[i].iov_len,/* maxsize */
2764 2, /* nsegments */
2765 ioc->mfi_sgl[i].iov_len,/* maxsegsize */
2766 BUS_DMA_ALLOCNOW, /* flags */
2767 &sc->mfi_kbuff_arr_dmat[i])) {
2768 device_printf(sc->mfi_dev,
2769 "Cannot allocate mfi_kbuff_arr_dmat tag\n");
2770 return (ENOMEM);
2771 }
2772
2773 if (bus_dmamem_alloc(sc->mfi_kbuff_arr_dmat[i],
2774 (void **)&sc->kbuff_arr[i], BUS_DMA_NOWAIT,
2775 &sc->mfi_kbuff_arr_dmamap[i])) {
2776 device_printf(sc->mfi_dev,
2777 "Cannot allocate mfi_kbuff_arr_dmamap memory\n");
2778 return (ENOMEM);
2779 }
2780
2781 bus_dmamap_load(sc->mfi_kbuff_arr_dmat[i],
2782 sc->mfi_kbuff_arr_dmamap[i], sc->kbuff_arr[i],
2783 ioc->mfi_sgl[i].iov_len, mfi_addr_cb,
2784 &sc->mfi_kbuff_arr_busaddr[i], 0);
2785
2786 if (!sc->kbuff_arr[i]) {
2787 device_printf(sc->mfi_dev,
2788 "Could not allocate memory for kbuff_arr info\n");
2789 return -1;
2790 }
2791 kern_sge[i].phys_addr = sc->mfi_kbuff_arr_busaddr[i];
2792 kern_sge[i].length = ioc->mfi_sgl[i].iov_len;
2793
2794 if (sizeof(bus_addr_t) == 8) {
2795 cm->cm_frame->stp.sgl.sg64[i].addr =
2796 kern_sge[i].phys_addr;
2797 cm->cm_frame->stp.sgl.sg64[i].len =
2798 ioc->mfi_sgl[i].iov_len;
2799 } else {
2800 cm->cm_frame->stp.sgl.sg32[i].len =
2801 kern_sge[i].phys_addr;
2802 cm->cm_frame->stp.sgl.sg32[i].len =
2803 ioc->mfi_sgl[i].iov_len;
2804 }
2805
2806 error = copyin(ioc->mfi_sgl[i].iov_base,
2807 sc->kbuff_arr[i],
2808 ioc->mfi_sgl[i].iov_len);
2809 if (error != 0) {
2810 device_printf(sc->mfi_dev, "Copy in failed\n");
2811 return error;
2812 }
2813 }
2814
2815 cm->cm_flags |=MFI_CMD_MAPPED;
2816 return 0;
2817 }
2818
2819 static int
2820 mfi_user_command(struct mfi_softc *sc, struct mfi_ioc_passthru *ioc)
2821 {
2822 struct mfi_command *cm;
2823 struct mfi_dcmd_frame *dcmd;
2824 void *ioc_buf = NULL;
2825 uint32_t context;
2826 int error = 0, locked;
2827
2828
2829 if (ioc->buf_size > 0) {
2830 ioc_buf = kmalloc(ioc->buf_size, M_MFIBUF, M_WAITOK);
2831 error = copyin(ioc->buf, ioc_buf, ioc->buf_size);
2832 if (error) {
2833 device_printf(sc->mfi_dev, "failed to copyin\n");
2834 kfree(ioc_buf, M_MFIBUF);
2835 return (error);
2836 }
2837 }
2838
2839 locked = mfi_config_lock(sc, ioc->ioc_frame.opcode);
2840
2841 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
2842 while ((cm = mfi_dequeue_free(sc)) == NULL)
2843 lksleep(mfi_user_command, &sc->mfi_io_lock, 0, "mfiioc", hz);
2844
2845 /* Save context for later */
2846 context = cm->cm_frame->header.context;
2847
2848 dcmd = &cm->cm_frame->dcmd;
2849 bcopy(&ioc->ioc_frame, dcmd, sizeof(struct mfi_dcmd_frame));
2850
2851 cm->cm_sg = &dcmd->sgl;
2852 cm->cm_total_frame_size = MFI_DCMD_FRAME_SIZE;
2853 cm->cm_data = ioc_buf;
2854 cm->cm_len = ioc->buf_size;
2855
2856 /* restore context */
2857 cm->cm_frame->header.context = context;
2858
2859 /* Cheat since we don't know if we're writing or reading */
2860 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_DATAOUT;
2861
2862 error = mfi_check_command_pre(sc, cm);
2863 if (error)
2864 goto out;
2865
2866 error = mfi_wait_command(sc, cm);
2867 if (error) {
2868 device_printf(sc->mfi_dev, "ioctl failed %d\n", error);
2869 goto out;
2870 }
2871 bcopy(dcmd, &ioc->ioc_frame, sizeof(struct mfi_dcmd_frame));
2872 mfi_check_command_post(sc, cm);
2873 out:
2874 mfi_release_command(cm);
2875 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
2876 mfi_config_unlock(sc, locked);
2877 if (ioc->buf_size > 0)
2878 error = copyout(ioc_buf, ioc->buf, ioc->buf_size);
2879 if (ioc_buf)
2880 kfree(ioc_buf, M_MFIBUF);
2881 return (error);
2882 }
2883
2884 #define PTRIN(p) ((void *)(uintptr_t)(p))
2885
2886 static int
2887 mfi_ioctl(struct dev_ioctl_args *ap)
2888 {
2889 cdev_t dev = ap->a_head.a_dev;
2890 u_long cmd = ap->a_cmd;
2891 int flag = ap->a_fflag;
2892 caddr_t arg = ap->a_data;
2893 struct mfi_softc *sc;
2894 union mfi_statrequest *ms;
2895 struct mfi_ioc_packet *ioc;
2896 struct mfi_ioc_aen *aen;
2897 struct mfi_command *cm = NULL;
2898 uint32_t context;
2899 union mfi_sense_ptr sense_ptr;
2900 uint8_t *data = NULL, *temp, *addr, skip_pre_post = 0;
2901 size_t len;
2902 int i, res;
2903 struct mfi_ioc_passthru *iop = (struct mfi_ioc_passthru *)arg;
2904 int error, locked;
2905
2906 sc = dev->si_drv1;
2907 error = 0;
2908
2909 if (sc->adpreset)
2910 return EBUSY;
2911
2912 if (sc->hw_crit_error)
2913 return EBUSY;
2914
2915 if (sc->issuepend_done == 0)
2916 return EBUSY;
2917
2918 switch (cmd) {
2919 case MFIIO_STATS:
2920 ms = (union mfi_statrequest *)arg;
2921 switch (ms->ms_item) {
2922 case MFIQ_FREE:
2923 case MFIQ_BIO:
2924 case MFIQ_READY:
2925 case MFIQ_BUSY:
2926 bcopy(&sc->mfi_qstat[ms->ms_item], &ms->ms_qstat,
2927 sizeof(struct mfi_qstat));
2928 break;
2929 default:
2930 error = ENOIOCTL;
2931 break;
2932 }
2933 break;
2934 case MFIIO_QUERY_DISK:
2935 {
2936 struct mfi_query_disk *qd;
2937 struct mfi_disk *ld;
2938
2939 qd = (struct mfi_query_disk *)arg;
2940 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
2941 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
2942 if (ld->ld_id == qd->array_id)
2943 break;
2944 }
2945 if (ld == NULL) {
2946 qd->present = 0;
2947 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
2948 return (0);
2949 }
2950 qd->present = 1;
2951 if (ld->ld_flags & MFI_DISK_FLAGS_OPEN)
2952 qd->open = 1;
2953 bzero(qd->devname, SPECNAMELEN + 1);
2954 ksnprintf(qd->devname, SPECNAMELEN, "mfid%d", ld->ld_unit);
2955 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
2956 break;
2957 }
2958 case MFI_CMD:
2959 {
2960 devclass_t devclass;
2961 ioc = (struct mfi_ioc_packet *)arg;
2962 int adapter;
2963
2964 adapter = ioc->mfi_adapter_no;
2965 if (device_get_unit(sc->mfi_dev) == 0 && adapter != 0) {
2966 devclass = devclass_find("mfi");
2967 sc = devclass_get_softc(devclass, adapter);
2968 }
2969 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
2970 if ((cm = mfi_dequeue_free(sc)) == NULL) {
2971 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
2972 return (EBUSY);
2973 }
2974 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
2975 locked = 0;
2976
2977 /*
2978 * save off original context since copying from user
2979 * will clobber some data
2980 */
2981 context = cm->cm_frame->header.context;
2982 cm->cm_frame->header.context = cm->cm_index;
2983
2984 bcopy(ioc->mfi_frame.raw, cm->cm_frame,
2985 2 * MEGAMFI_FRAME_SIZE);
2986 cm->cm_total_frame_size = (sizeof(union mfi_sgl)
2987 * ioc->mfi_sge_count) + ioc->mfi_sgl_off;
2988 cm->cm_frame->header.scsi_status = 0;
2989 cm->cm_frame->header.pad0 = 0;
2990 if (ioc->mfi_sge_count) {
2991 cm->cm_sg =
2992 (union mfi_sgl *)&cm->cm_frame->bytes[ioc->mfi_sgl_off];
2993 }
2994 cm->cm_flags = 0;
2995 if (cm->cm_frame->header.flags & MFI_FRAME_DATAIN)
2996 cm->cm_flags |= MFI_CMD_DATAIN;
2997 if (cm->cm_frame->header.flags & MFI_FRAME_DATAOUT)
2998 cm->cm_flags |= MFI_CMD_DATAOUT;
2999 /* Legacy app shim */
3000 if (cm->cm_flags == 0)
3001 cm->cm_flags |= MFI_CMD_DATAIN | MFI_CMD_DATAOUT;
3002 cm->cm_len = cm->cm_frame->header.data_len;
3003 if (cm->cm_frame->header.cmd == MFI_CMD_STP) {
3004 cm->cm_stp_len = ioc->mfi_sgl[0].iov_len;
3005 cm->cm_len += cm->cm_stp_len;
3006 }
3007 if (cm->cm_len &&
3008 (cm->cm_flags & (MFI_CMD_DATAIN | MFI_CMD_DATAOUT))) {
3009 cm->cm_data = data = kmalloc(cm->cm_len, M_MFIBUF,
3010 M_WAITOK | M_ZERO);
3011 } else {
3012 cm->cm_data = 0;
3013 }
3014
3015 /* restore header context */
3016 cm->cm_frame->header.context = context;
3017
3018 if (cm->cm_frame->header.cmd == MFI_CMD_STP) {
3019 res = mfi_stp_cmd(sc, cm, arg);
3020 if (res != 0)
3021 goto out;
3022 } else {
3023 temp = data;
3024 if ((cm->cm_flags & MFI_CMD_DATAOUT) ||
3025 (cm->cm_frame->header.cmd == MFI_CMD_STP)) {
3026 for (i = 0; i < ioc->mfi_sge_count; i++) {
3027 addr = ioc->mfi_sgl[i].iov_base;
3028 len = ioc->mfi_sgl[i].iov_len;
3029 error = copyin(addr, temp, len);
3030 if (error != 0) {
3031 device_printf(sc->mfi_dev,
3032 "Copy in failed\n");
3033 goto out;
3034 }
3035 temp = &temp[len];
3036 }
3037 }
3038 }
3039
3040 if (cm->cm_frame->header.cmd == MFI_CMD_DCMD)
3041 locked = mfi_config_lock(sc,
3042 cm->cm_frame->dcmd.opcode);
3043
3044 if (cm->cm_frame->header.cmd == MFI_CMD_PD_SCSI_IO) {
3045 cm->cm_frame->pass.sense_addr_lo =
3046 (uint32_t)cm->cm_sense_busaddr;
3047 cm->cm_frame->pass.sense_addr_hi =
3048 (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32);
3049 }
3050 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
3051 skip_pre_post = mfi_check_for_sscd(sc, cm);
3052 if (!skip_pre_post) {
3053 error = mfi_check_command_pre(sc, cm);
3054 if (error) {
3055 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
3056 goto out;
3057 }
3058 }
3059
3060 if ((error = mfi_wait_command(sc, cm)) != 0) {
3061 device_printf(sc->mfi_dev,
3062 "Controller polled failed\n");
3063 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
3064 goto out;
3065 }
3066
3067 if (!skip_pre_post)
3068 mfi_check_command_post(sc, cm);
3069 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
3070
3071 if (cm->cm_frame->header.cmd != MFI_CMD_STP) {
3072 temp = data;
3073 if ((cm->cm_flags & MFI_CMD_DATAIN) ||
3074 (cm->cm_frame->header.cmd == MFI_CMD_STP)) {
3075 for (i = 0; i < ioc->mfi_sge_count; i++) {
3076 addr = ioc->mfi_sgl[i].iov_base;
3077 len = ioc->mfi_sgl[i].iov_len;
3078 error = copyout(temp, addr, len);
3079 if (error != 0) {
3080 device_printf(sc->mfi_dev,
3081 "Copy out failed\n");
3082 goto out;
3083 }
3084 temp = &temp[len];
3085 }
3086 }
3087 }
3088
3089 if (ioc->mfi_sense_len) {
3090 /* get user-space sense ptr then copy out sense */
3091 bcopy(&ioc->mfi_frame.raw[ioc->mfi_sense_off],
3092 &sense_ptr.sense_ptr_data[0],
3093 sizeof(sense_ptr.sense_ptr_data));
3094 error = copyout(cm->cm_sense, sense_ptr.user_space,
3095 ioc->mfi_sense_len);
3096 if (error != 0) {
3097 device_printf(sc->mfi_dev,
3098 "Copy out failed\n");
3099 goto out;
3100 }
3101 }
3102
3103 ioc->mfi_frame.hdr.cmd_status = cm->cm_frame->header.cmd_status;
3104 out:
3105 mfi_config_unlock(sc, locked);
3106 if (data)
3107 kfree(data, M_MFIBUF);
3108 if (cm->cm_frame->header.cmd == MFI_CMD_STP) {
3109 for (i = 0; i < 2; i++) {
3110 if (sc->kbuff_arr[i]) {
3111 if (sc->mfi_kbuff_arr_busaddr != 0)
3112 bus_dmamap_unload(
3113 sc->mfi_kbuff_arr_dmat[i],
3114 sc->mfi_kbuff_arr_dmamap[i]
3115 );
3116 if (sc->kbuff_arr[i] != NULL)
3117 bus_dmamem_free(
3118 sc->mfi_kbuff_arr_dmat[i],
3119 sc->kbuff_arr[i],
3120 sc->mfi_kbuff_arr_dmamap[i]
3121 );
3122 if (sc->mfi_kbuff_arr_dmat[i] != NULL)
3123 bus_dma_tag_destroy(
3124 sc->mfi_kbuff_arr_dmat[i]);
3125 }
3126 }
3127 }
3128 if (cm) {
3129 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
3130 mfi_release_command(cm);
3131 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
3132 }
3133
3134 break;
3135 }
3136 case MFI_SET_AEN:
3137 aen = (struct mfi_ioc_aen *)arg;
3138 error = mfi_aen_register(sc, aen->aen_seq_num,
3139 aen->aen_class_locale);
3140
3141 break;
3142 case MFI_LINUX_CMD_2: /* Firmware Linux ioctl shim */
3143 {
3144 devclass_t devclass;
3145 struct mfi_linux_ioc_packet l_ioc;
3146 int adapter;
3147
3148 devclass = devclass_find("mfi");
3149 if (devclass == NULL)
3150 return (ENOENT);
3151
3152 error = copyin(arg, &l_ioc, sizeof(l_ioc));
3153 if (error)
3154 return (error);
3155 adapter = l_ioc.lioc_adapter_no;
3156 sc = devclass_get_softc(devclass, adapter);
3157 if (sc == NULL)
3158 return (ENOENT);
3159 return (mfi_linux_ioctl_int(sc->mfi_cdev,
3160 cmd, arg, flag));
3161 break;
3162 }
3163 case MFI_LINUX_SET_AEN_2: /* AEN Linux ioctl shim */
3164 {
3165 devclass_t devclass;
3166 struct mfi_linux_ioc_aen l_aen;
3167 int adapter;
3168
3169 devclass = devclass_find("mfi");
3170 if (devclass == NULL)
3171 return (ENOENT);
3172
3173 error = copyin(arg, &l_aen, sizeof(l_aen));
3174 if (error)
3175 return (error);
3176 adapter = l_aen.laen_adapter_no;
3177 sc = devclass_get_softc(devclass, adapter);
3178 if (sc == NULL)
3179 return (ENOENT);
3180 return (mfi_linux_ioctl_int(sc->mfi_cdev,
3181 cmd, arg, flag));
3182 break;
3183 }
3184 case MFIIO_PASSTHRU:
3185 error = mfi_user_command(sc, iop);
3186 break;
3187 default:
3188 device_printf(sc->mfi_dev, "IOCTL 0x%lx not handled\n", cmd);
3189 error = ENOENT;
3190 break;
3191 }
3192
3193 return (error);
3194 }
3195
3196 static int
3197 mfi_linux_ioctl_int(struct cdev *dev, u_long cmd, caddr_t arg, int flag)
3198 {
3199 struct mfi_softc *sc;
3200 struct mfi_linux_ioc_packet l_ioc;
3201 struct mfi_linux_ioc_aen l_aen;
3202 struct mfi_command *cm = NULL;
3203 struct mfi_aen *mfi_aen_entry;
3204 union mfi_sense_ptr sense_ptr;
3205 uint32_t context;
3206 uint8_t *data = NULL, *temp;
3207 int i;
3208 int error, locked;
3209
3210 sc = dev->si_drv1;
3211 error = 0;
3212 switch (cmd) {
3213 case MFI_LINUX_CMD_2: /* Firmware Linux ioctl shim */
3214 error = copyin(arg, &l_ioc, sizeof(l_ioc));
3215 if (error != 0)
3216 return (error);
3217
3218 if (l_ioc.lioc_sge_count > MAX_LINUX_IOCTL_SGE) {
3219 return (EINVAL);
3220 }
3221
3222 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
3223 if ((cm = mfi_dequeue_free(sc)) == NULL) {
3224 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
3225 return (EBUSY);
3226 }
3227 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
3228 locked = 0;
3229
3230 /*
3231 * save off original context since copying from user
3232 * will clobber some data
3233 */
3234 context = cm->cm_frame->header.context;
3235
3236 bcopy(l_ioc.lioc_frame.raw, cm->cm_frame,
3237 2 * MFI_DCMD_FRAME_SIZE); /* this isn't quite right */
3238 cm->cm_total_frame_size = (sizeof(union mfi_sgl)
3239 * l_ioc.lioc_sge_count) + l_ioc.lioc_sgl_off;
3240 cm->cm_frame->header.scsi_status = 0;
3241 cm->cm_frame->header.pad0 = 0;
3242 if (l_ioc.lioc_sge_count)
3243 cm->cm_sg =
3244 (union mfi_sgl *)&cm->cm_frame->bytes[l_ioc.lioc_sgl_off];
3245 cm->cm_flags = 0;
3246 if (cm->cm_frame->header.flags & MFI_FRAME_DATAIN)
3247 cm->cm_flags |= MFI_CMD_DATAIN;
3248 if (cm->cm_frame->header.flags & MFI_FRAME_DATAOUT)
3249 cm->cm_flags |= MFI_CMD_DATAOUT;
3250 cm->cm_len = cm->cm_frame->header.data_len;
3251 if (cm->cm_len &&
3252 (cm->cm_flags & (MFI_CMD_DATAIN | MFI_CMD_DATAOUT))) {
3253 cm->cm_data = data = kmalloc(cm->cm_len, M_MFIBUF,
3254 M_WAITOK | M_ZERO);
3255 } else {
3256 cm->cm_data = 0;
3257 }
3258
3259 /* restore header context */
3260 cm->cm_frame->header.context = context;
3261
3262 temp = data;
3263 if (cm->cm_flags & MFI_CMD_DATAOUT) {
3264 for (i = 0; i < l_ioc.lioc_sge_count; i++) {
3265 error = copyin(PTRIN(l_ioc.lioc_sgl[i].iov_base),
3266 temp,
3267 l_ioc.lioc_sgl[i].iov_len);
3268 if (error != 0) {
3269 device_printf(sc->mfi_dev,
3270 "Copy in failed\n");
3271 goto out;
3272 }
3273 temp = &temp[l_ioc.lioc_sgl[i].iov_len];
3274 }
3275 }
3276
3277 if (cm->cm_frame->header.cmd == MFI_CMD_DCMD)
3278 locked = mfi_config_lock(sc, cm->cm_frame->dcmd.opcode);
3279
3280 if (cm->cm_frame->header.cmd == MFI_CMD_PD_SCSI_IO) {
3281 cm->cm_frame->pass.sense_addr_lo =
3282 (uint32_t)cm->cm_sense_busaddr;
3283 cm->cm_frame->pass.sense_addr_hi =
3284 (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32);
3285 }
3286
3287 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
3288 error = mfi_check_command_pre(sc, cm);
3289 if (error) {
3290 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
3291 goto out;
3292 }
3293
3294 if ((error = mfi_wait_command(sc, cm)) != 0) {
3295 device_printf(sc->mfi_dev,
3296 "Controller polled failed\n");
3297 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
3298 goto out;
3299 }
3300
3301 mfi_check_command_post(sc, cm);
3302 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
3303
3304 temp = data;
3305 if (cm->cm_flags & MFI_CMD_DATAIN) {
3306 for (i = 0; i < l_ioc.lioc_sge_count; i++) {
3307 error = copyout(temp,
3308 PTRIN(l_ioc.lioc_sgl[i].iov_base),
3309 l_ioc.lioc_sgl[i].iov_len);
3310 if (error != 0) {
3311 device_printf(sc->mfi_dev,
3312 "Copy out failed\n");
3313 goto out;
3314 }
3315 temp = &temp[l_ioc.lioc_sgl[i].iov_len];
3316 }
3317 }
3318
3319 if (l_ioc.lioc_sense_len) {
3320 /* get user-space sense ptr then copy out sense */
3321 bcopy(&((struct mfi_linux_ioc_packet*)arg)
3322 ->lioc_frame.raw[l_ioc.lioc_sense_off],
3323 &sense_ptr.sense_ptr_data[0],
3324 sizeof(sense_ptr.sense_ptr_data));
3325 #ifdef __x86_64__
3326 /*
3327 * only 32bit Linux support so zero out any
3328 * address over 32bit
3329 */
3330 sense_ptr.addr.high = 0;
3331 #endif
3332 error = copyout(cm->cm_sense, sense_ptr.user_space,
3333 l_ioc.lioc_sense_len);
3334 if (error != 0) {
3335 device_printf(sc->mfi_dev,
3336 "Copy out failed\n");
3337 goto out;
3338 }
3339 }
3340
3341 error = copyout(&cm->cm_frame->header.cmd_status,
3342 &((struct mfi_linux_ioc_packet*)arg)
3343 ->lioc_frame.hdr.cmd_status,
3344 1);
3345 if (error != 0) {
3346 device_printf(sc->mfi_dev,
3347 "Copy out failed\n");
3348 goto out;
3349 }
3350
3351 out:
3352 mfi_config_unlock(sc, locked);
3353 if (data)
3354 kfree(data, M_MFIBUF);
3355 if (cm) {
3356 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
3357 mfi_release_command(cm);
3358 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
3359 }
3360
3361 return (error);
3362 case MFI_LINUX_SET_AEN_2: /* AEN Linux ioctl shim */
3363 error = copyin(arg, &l_aen, sizeof(l_aen));
3364 if (error != 0)
3365 return (error);
3366 kprintf("AEN IMPLEMENTED for pid %d\n", curproc->p_pid);
3367 mfi_aen_entry = kmalloc(sizeof(struct mfi_aen), M_MFIBUF,
3368 M_WAITOK);
3369 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
3370 if (mfi_aen_entry != NULL) {
3371 mfi_aen_entry->p = curproc;
3372 TAILQ_INSERT_TAIL(&sc->mfi_aen_pids, mfi_aen_entry,
3373 aen_link);
3374 }
3375 error = mfi_aen_register(sc, l_aen.laen_seq_num,
3376 l_aen.laen_class_locale);
3377
3378 if (error != 0) {
3379 TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry,
3380 aen_link);
3381 kfree(mfi_aen_entry, M_MFIBUF);
3382 }
3383 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
3384
3385 return (error);
3386 default:
3387 device_printf(sc->mfi_dev, "IOCTL 0x%lx not handled\n", cmd);
3388 error = ENOENT;
3389 break;
3390 }
3391
3392 return (error);
3393 }
3394
3395 static int
3396 mfi_kqfilter(struct dev_kqfilter_args *ap)
3397 {
3398 cdev_t dev = ap->a_head.a_dev;
3399 struct knote *kn = ap->a_kn;
3400 struct mfi_softc *sc;
3401 struct klist *klist;
3402
3403 ap->a_result = 0;
3404 sc = dev->si_drv1;
3405
3406 switch (kn->kn_filter) {
3407 case EVFILT_READ:
3408 kn->kn_fop = &mfi_read_filterops;
3409 kn->kn_hook = (caddr_t)sc;
3410 break;
3411 case EVFILT_WRITE:
3412 kn->kn_fop = &mfi_write_filterops;
3413 kn->kn_hook = (caddr_t)sc;
3414 break;
3415 default:
3416 ap->a_result = EOPNOTSUPP;
3417 return (0);
3418 }
3419
3420 klist = &sc->mfi_kq.ki_note;
3421 knote_insert(klist, kn);
3422
3423 return(0);
3424 }
3425
3426 static void
3427 mfi_filter_detach(struct knote *kn)
3428 {
3429 struct mfi_softc *sc = (struct mfi_softc *)kn->kn_hook;
3430 struct klist *klist = &sc->mfi_kq.ki_note;
3431
3432 knote_remove(klist, kn);
3433 }
3434
3435 static int
3436 mfi_filter_read(struct knote *kn, long hint)
3437 {
3438 struct mfi_softc *sc = (struct mfi_softc *)kn->kn_hook;
3439 int ready = 0;
3440
3441 if (sc->mfi_aen_triggered != 0) {
3442 ready = 1;
3443 sc->mfi_aen_triggered = 0;
3444 }
3445 if (sc->mfi_aen_triggered == 0 && sc->mfi_aen_cm == NULL)
3446 kn->kn_flags |= EV_ERROR;
3447
3448 if (ready == 0)
3449 sc->mfi_poll_waiting = 1;
3450
3451 return (ready);
3452 }
3453
3454 static int
3455 mfi_filter_write(struct knote *kn, long hint)
3456 {
3457 return (0);
3458 }
3459
3460 static void
3461 mfi_dump_all(void)
3462 {
3463 struct mfi_softc *sc;
3464 struct mfi_command *cm;
3465 devclass_t dc;
3466 time_t deadline;
3467 int timedout;
3468 int i;
3469
3470 dc = devclass_find("mfi");
3471 if (dc == NULL) {
3472 kprintf("No mfi dev class\n");
3473 return;
3474 }
3475
3476 for (i = 0; ; i++) {
3477 sc = devclass_get_softc(dc, i);
3478 if (sc == NULL)
3479 break;
3480 device_printf(sc->mfi_dev, "Dumping\n\n");
3481 timedout = 0;
3482 deadline = time_second - MFI_CMD_TIMEOUT;
3483 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
3484 TAILQ_FOREACH(cm, &sc->mfi_busy, cm_link) {
3485 if (cm->cm_timestamp < deadline) {
3486 device_printf(sc->mfi_dev,
3487 "COMMAND %p TIMEOUT AFTER %d SECONDS\n",
3488 cm, (int)(time_second - cm->cm_timestamp));
3489 MFI_PRINT_CMD(cm);
3490 timedout++;
3491 }
3492 }
3493
3494 #if 0
3495 if (timedout)
3496 MFI_DUMP_CMDS(SC);
3497 #endif
3498
3499 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
3500 }
3501
3502 return;
3503 }
3504
3505 static void
3506 mfi_timeout(void *data)
3507 {
3508 struct mfi_softc *sc = (struct mfi_softc *)data;
3509 struct mfi_command *cm;
3510 time_t deadline;
3511 int timedout = 0;
3512
3513 deadline = time_second - MFI_CMD_TIMEOUT;
3514 if (sc->adpreset == 0) {
3515 if (!mfi_tbolt_reset(sc)) {
3516 callout_reset(&sc->mfi_watchdog_callout,
3517 MFI_CMD_TIMEOUT * hz, mfi_timeout, sc);
3518 return;
3519 }
3520 }
3521 lockmgr(&sc->mfi_io_lock, LK_EXCLUSIVE);
3522 TAILQ_FOREACH(cm, &sc->mfi_busy, cm_link) {
3523 if (sc->mfi_aen_cm == cm)
3524 continue;
3525 if ((sc->mfi_aen_cm != cm) && (cm->cm_timestamp < deadline)) {
3526 if (sc->adpreset != 0 && sc->issuepend_done == 0) {
3527 cm->cm_timestamp = time_second;
3528 } else {
3529 device_printf(sc->mfi_dev,
3530 "COMMAND %p TIMEOUT AFTER %d SECONDS\n",
3531 cm, (int)(time_second - cm->cm_timestamp));
3532 MFI_PRINT_CMD(cm);
3533 MFI_VALIDATE_CMD(sc, cm);
3534 timedout++;
3535 }
3536 }
3537 }
3538
3539 #if 0
3540 if (timedout)
3541 MFI_DUMP_CMDS(SC);
3542 #endif
3543
3544 lockmgr(&sc->mfi_io_lock, LK_RELEASE);
3545
3546 callout_reset(&sc->mfi_watchdog_callout, MFI_CMD_TIMEOUT * hz,
3547 mfi_timeout, sc);
3548
3549 if (0)
3550 mfi_dump_all();
3551 return;
3552 }
DragonFly BSD