1 /*-
2 * Redistribution and use in source and binary forms, with or without
3 * modification, are permitted provided that the following conditions
4 * are met:
5 *
6 * Copyright 1994-2009 The FreeBSD Project.
7 * All rights reserved.
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE FREEBSD PROJECT``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FREEBSD PROJECT OR
19 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20 * EXEMPLARY,OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22 * PROFITS; OR BUSINESS INTERRUPTION)HOWEVER CAUSED AND ON ANY THEORY
23 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 *
27 * The views and conclusions contained in the software and documentation
28 * are those of the authors and should not be interpreted as representing
29 * official policies,either expressed or implied, of the FreeBSD Project.
30 */
31
32
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
35
36 #include "opt_mfi.h"
37
38 #include <sys/param.h>
39 #include <sys/types.h>
40 #include <sys/kernel.h>
41 #include <sys/selinfo.h>
42 #include <sys/bus.h>
43 #include <sys/conf.h>
44 #include <sys/bio.h>
45 #include <sys/ioccom.h>
46 #include <sys/eventhandler.h>
47 #include <sys/callout.h>
48 #include <sys/uio.h>
49 #include <machine/bus.h>
50 #include <sys/sysctl.h>
51 #include <sys/systm.h>
52 #include <sys/malloc.h>
53
54 #include <dev/mfi/mfireg.h>
55 #include <dev/mfi/mfi_ioctl.h>
56 #include <dev/mfi/mfivar.h>
57
58 struct mfi_cmd_tbolt *mfi_tbolt_get_cmd(struct mfi_softc *sc);
59 union mfi_mpi2_request_descriptor *
60 mfi_tbolt_get_request_descriptor(struct mfi_softc *sc, uint16_t index);
61 void mfi_tbolt_complete_cmd(struct mfi_softc *sc);
62 int mfi_tbolt_build_io(struct mfi_softc *sc, struct mfi_command *mfi_cmd,
63 struct mfi_cmd_tbolt *cmd);
64 static inline void mfi_tbolt_return_cmd(struct mfi_softc *sc,
65 struct mfi_cmd_tbolt *cmd);
66 union mfi_mpi2_request_descriptor *mfi_tbolt_build_mpt_cmd(struct mfi_softc
67 *sc, struct mfi_command *cmd);
68 uint8_t
69 mfi_build_mpt_pass_thru(struct mfi_softc *sc, struct mfi_command *mfi_cmd);
70 union mfi_mpi2_request_descriptor *mfi_build_and_issue_cmd(struct mfi_softc
71 *sc, struct mfi_command *mfi_cmd);
72 int mfi_tbolt_is_ldio(struct mfi_command *mfi_cmd);
73 void mfi_tbolt_build_ldio(struct mfi_softc *sc, struct mfi_command *mfi_cmd,
74 struct mfi_cmd_tbolt *cmd);
75 static int mfi_tbolt_make_sgl(struct mfi_softc *sc, struct mfi_command
76 *mfi_cmd, pMpi25IeeeSgeChain64_t sgl_ptr, struct mfi_cmd_tbolt *cmd);
77 static int mfi_tbolt_build_cdb(struct mfi_softc *sc, struct mfi_command
78 *mfi_cmd, uint8_t *cdb);
79 void
80 map_tbolt_cmd_status(struct mfi_command *mfi_cmd, uint8_t status,
81 uint8_t ext_status);
82 static void mfi_issue_pending_cmds_again (struct mfi_softc *sc);
83 static void mfi_kill_hba (struct mfi_softc *sc);
84 static void mfi_process_fw_state_chg_isr(void *arg);
85 static void mfi_sync_map_complete(struct mfi_command *);
86 static void mfi_queue_map_sync(struct mfi_softc *sc);
87
88 #define MFI_FUSION_ENABLE_INTERRUPT_MASK (0x00000008)
89
90 void
91 mfi_tbolt_enable_intr_ppc(struct mfi_softc *sc)
92 {
93 MFI_WRITE4(sc, MFI_OMSK, ~MFI_FUSION_ENABLE_INTERRUPT_MASK);
94 MFI_READ4(sc, MFI_OMSK);
95 }
96
97 void
98 mfi_tbolt_disable_intr_ppc(struct mfi_softc *sc)
99 {
100 MFI_WRITE4(sc, MFI_OMSK, 0xFFFFFFFF);
101 MFI_READ4(sc, MFI_OMSK);
102 }
103
104 int32_t
105 mfi_tbolt_read_fw_status_ppc(struct mfi_softc *sc)
106 {
107 return MFI_READ4(sc, MFI_OSP0);
108 }
109
110 int32_t
111 mfi_tbolt_check_clear_intr_ppc(struct mfi_softc *sc)
112 {
113 int32_t status, mfi_status = 0;
114
115 status = MFI_READ4(sc, MFI_OSTS);
116
117 if (status & 1) {
118 MFI_WRITE4(sc, MFI_OSTS, status);
119 MFI_READ4(sc, MFI_OSTS);
120 if (status & MFI_STATE_CHANGE_INTERRUPT) {
121 mfi_status |= MFI_FIRMWARE_STATE_CHANGE;
122 }
123
124 return mfi_status;
125 }
126 if (!(status & MFI_FUSION_ENABLE_INTERRUPT_MASK))
127 return 1;
128
129 MFI_READ4(sc, MFI_OSTS);
130 return 0;
131 }
132
133
134 void
135 mfi_tbolt_issue_cmd_ppc(struct mfi_softc *sc, bus_addr_t bus_add,
136 uint32_t frame_cnt)
137 {
138 bus_add |= (MFI_REQ_DESCRIPT_FLAGS_MFA
139 << MFI_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
140 MFI_WRITE4(sc, MFI_IQPL, (uint32_t)bus_add);
141 MFI_WRITE4(sc, MFI_IQPH, (uint32_t)((uint64_t)bus_add >> 32));
142 }
143
144 /*
145 * mfi_tbolt_adp_reset - For controller reset
146 * @regs: MFI register set
147 */
148 int
149 mfi_tbolt_adp_reset(struct mfi_softc *sc)
150 {
151 int retry = 0, i = 0;
152 int HostDiag;
153
154 MFI_WRITE4(sc, MFI_WSR, 0xF);
155 MFI_WRITE4(sc, MFI_WSR, 4);
156 MFI_WRITE4(sc, MFI_WSR, 0xB);
157 MFI_WRITE4(sc, MFI_WSR, 2);
158 MFI_WRITE4(sc, MFI_WSR, 7);
159 MFI_WRITE4(sc, MFI_WSR, 0xD);
160
161 for (i = 0; i < 10000; i++) ;
162
163 HostDiag = (uint32_t)MFI_READ4(sc, MFI_HDR);
164
165 while (!( HostDiag & DIAG_WRITE_ENABLE)) {
166 for (i = 0; i < 1000; i++);
167 HostDiag = (uint32_t)MFI_READ4(sc, MFI_HDR);
168 device_printf(sc->mfi_dev, "ADP_RESET_TBOLT: retry time=%x, "
169 "hostdiag=%x\n", retry, HostDiag);
170
171 if (retry++ >= 100)
172 return 1;
173 }
174
175 device_printf(sc->mfi_dev, "ADP_RESET_TBOLT: HostDiag=%x\n", HostDiag);
176
177 MFI_WRITE4(sc, MFI_HDR, (HostDiag | DIAG_RESET_ADAPTER));
178
179 for (i=0; i < 10; i++) {
180 for (i = 0; i < 10000; i++);
181 }
182
183 HostDiag = (uint32_t)MFI_READ4(sc, MFI_RSR);
184 while (HostDiag & DIAG_RESET_ADAPTER) {
185 for (i = 0; i < 1000; i++) ;
186 HostDiag = (uint32_t)MFI_READ4(sc, MFI_RSR);
187 device_printf(sc->mfi_dev, "ADP_RESET_TBOLT: retry time=%x, "
188 "hostdiag=%x\n", retry, HostDiag);
189
190 if (retry++ >= 1000)
191 return 1;
192 }
193 return 0;
194 }
195
196 /*
197 * This routine initialize Thunderbolt specific device information
198 */
199 void
200 mfi_tbolt_init_globals(struct mfi_softc *sc)
201 {
202 /* Initialize single reply size and Message size */
203 sc->reply_size = MEGASAS_THUNDERBOLT_REPLY_SIZE;
204 sc->raid_io_msg_size = MEGASAS_THUNDERBOLT_NEW_MSG_SIZE;
205
206 /*
207 * Calculating how many SGEs allowed in a allocated main message
208 * (size of the Message - Raid SCSI IO message size(except SGE))
209 * / size of SGE
210 * (0x100 - (0x90 - 0x10)) / 0x10 = 8
211 */
212 sc->max_SGEs_in_main_message =
213 (uint8_t)((sc->raid_io_msg_size
214 - (sizeof(struct mfi_mpi2_request_raid_scsi_io)
215 - sizeof(MPI2_SGE_IO_UNION))) / sizeof(MPI2_SGE_IO_UNION));
216 /*
217 * (Command frame size allocaed in SRB ext - Raid SCSI IO message size)
218 * / size of SGL ;
219 * (1280 - 256) / 16 = 64
220 */
221 sc->max_SGEs_in_chain_message = (MR_COMMAND_SIZE
222 - sc->raid_io_msg_size) / sizeof(MPI2_SGE_IO_UNION);
223 /*
224 * (0x08-1) + 0x40 = 0x47 - 0x01 = 0x46 one is left for command
225 * colscing
226 */
227 sc->mfi_max_sge = (sc->max_SGEs_in_main_message - 1)
228 + sc->max_SGEs_in_chain_message - 1;
229 /*
230 * This is the offset in number of 4 * 32bit words to the next chain
231 * (0x100 - 0x10)/0x10 = 0xF(15)
232 */
233 sc->chain_offset_value_for_main_message = (sc->raid_io_msg_size
234 - sizeof(MPI2_SGE_IO_UNION))/16;
235 sc->chain_offset_value_for_mpt_ptmsg
236 = offsetof(struct mfi_mpi2_request_raid_scsi_io, SGL)/16;
237 sc->mfi_cmd_pool_tbolt = NULL;
238 sc->request_desc_pool = NULL;
239 }
240
241 /*
242 * This function calculates the memory requirement for Thunderbolt
243 * controller, returns the total required memory in bytes
244 */
245
246 uint32_t
247 mfi_tbolt_get_memory_requirement(struct mfi_softc *sc)
248 {
249 uint32_t size;
250 size = MEGASAS_THUNDERBOLT_MSG_ALLIGNMENT; /* for Alignment */
251 size += sc->raid_io_msg_size * (sc->mfi_max_fw_cmds + 1);
252 size += sc->reply_size * sc->mfi_max_fw_cmds;
253 /* this is for SGL's */
254 size += MEGASAS_MAX_SZ_CHAIN_FRAME * sc->mfi_max_fw_cmds;
255 return size;
256 }
257
258 /*
259 * Description:
260 * This function will prepare message pools for the Thunderbolt controller
261 * Arguments:
262 * DevExt - HBA miniport driver's adapter data storage structure
263 * pMemLocation - start of the memory allocated for Thunderbolt.
264 * Return Value:
265 * TRUE if successful
266 * FALSE if failed
267 */
268 int
269 mfi_tbolt_init_desc_pool(struct mfi_softc *sc, uint8_t* mem_location,
270 uint32_t tbolt_contg_length)
271 {
272 uint32_t offset = 0;
273 uint8_t *addr = mem_location;
274
275 /* Request Descriptor Base physical Address */
276
277 /* For Request Decriptors Virtual Memory */
278 /* Initialise the aligned IO Frames Virtual Memory Pointer */
279 if (((uintptr_t)addr) & (0xFF)) {
280 addr = &addr[sc->raid_io_msg_size];
281 addr = (uint8_t *)((uintptr_t)addr & (~0xFF));
282 sc->request_message_pool_align = addr;
283 } else
284 sc->request_message_pool_align = addr;
285
286 offset = sc->request_message_pool_align - sc->request_message_pool;
287 sc->request_msg_busaddr = sc->mfi_tb_busaddr + offset;
288
289 /* DJA XXX should this be bus dma ??? */
290 /* Skip request message pool */
291 addr = &addr[sc->raid_io_msg_size * (sc->mfi_max_fw_cmds + 1)];
292 /* Reply Frame Pool is initialized */
293 sc->reply_frame_pool = (struct mfi_mpi2_reply_header *) addr;
294 if (((uintptr_t)addr) & (0xFF)) {
295 addr = &addr[sc->reply_size];
296 addr = (uint8_t *)((uintptr_t)addr & (~0xFF));
297 }
298 sc->reply_frame_pool_align
299 = (struct mfi_mpi2_reply_header *)addr;
300
301 offset = (uintptr_t)sc->reply_frame_pool_align
302 - (uintptr_t)sc->request_message_pool;
303 sc->reply_frame_busaddr = sc->mfi_tb_busaddr + offset;
304
305 /* Skip Reply Frame Pool */
306 addr += sc->reply_size * sc->mfi_max_fw_cmds;
307 sc->reply_pool_limit = addr;
308
309 /* initializing reply address to 0xFFFFFFFF */
310 memset((uint8_t *)sc->reply_frame_pool, 0xFF,
311 (sc->reply_size * sc->mfi_max_fw_cmds));
312
313 offset = sc->reply_size * sc->mfi_max_fw_cmds;
314 sc->sg_frame_busaddr = sc->reply_frame_busaddr + offset;
315 /* initialize the last_reply_idx to 0 */
316 sc->last_reply_idx = 0;
317 offset = (sc->sg_frame_busaddr + (MEGASAS_MAX_SZ_CHAIN_FRAME *
318 sc->mfi_max_fw_cmds)) - sc->mfi_tb_busaddr;
319 if (offset > tbolt_contg_length)
320 device_printf(sc->mfi_dev, "Error:Initialized more than "
321 "allocated\n");
322 return 0;
323 }
324
325 /*
326 * This routine prepare and issue INIT2 frame to the Firmware
327 */
328
329 int
330 mfi_tbolt_init_MFI_queue(struct mfi_softc *sc)
331 {
332 struct MPI2_IOC_INIT_REQUEST *mpi2IocInit;
333 struct mfi_init_frame *mfi_init;
334 uintptr_t offset = 0;
335 bus_addr_t phyAddress;
336 MFI_ADDRESS *mfiAddressTemp;
337 struct mfi_command *cm;
338 int error;
339
340 mpi2IocInit = (struct MPI2_IOC_INIT_REQUEST *)sc->mfi_tb_ioc_init_desc;
341 /* Check if initialization is already completed */
342 if (sc->MFA_enabled) {
343 return 1;
344 }
345
346 mtx_lock(&sc->mfi_io_lock);
347 if ((cm = mfi_dequeue_free(sc)) == NULL) {
348 mtx_unlock(&sc->mfi_io_lock);
349 return (EBUSY);
350 }
351 cm->cm_frame = (union mfi_frame *)((uintptr_t)sc->mfi_tb_init);
352 cm->cm_frame_busaddr = sc->mfi_tb_init_busaddr;
353 cm->cm_dmamap = sc->mfi_tb_init_dmamap;
354 cm->cm_frame->header.context = 0;
355 cm->cm_sc = sc;
356 cm->cm_index = 0;
357
358 /*
359 * Abuse the SG list area of the frame to hold the init_qinfo
360 * object;
361 */
362 mfi_init = &cm->cm_frame->init;
363
364 bzero(mpi2IocInit, sizeof(struct MPI2_IOC_INIT_REQUEST));
365 mpi2IocInit->Function = MPI2_FUNCTION_IOC_INIT;
366 mpi2IocInit->WhoInit = MPI2_WHOINIT_HOST_DRIVER;
367
368 /* set MsgVersion and HeaderVersion host driver was built with */
369 mpi2IocInit->MsgVersion = MPI2_VERSION;
370 mpi2IocInit->HeaderVersion = MPI2_HEADER_VERSION;
371 mpi2IocInit->SystemRequestFrameSize = sc->raid_io_msg_size/4;
372 mpi2IocInit->ReplyDescriptorPostQueueDepth
373 = (uint16_t)sc->mfi_max_fw_cmds;
374 mpi2IocInit->ReplyFreeQueueDepth = 0; /* Not supported by MR. */
375
376 /* Get physical address of reply frame pool */
377 offset = (uintptr_t) sc->reply_frame_pool_align
378 - (uintptr_t)sc->request_message_pool;
379 phyAddress = sc->mfi_tb_busaddr + offset;
380 mfiAddressTemp =
381 (MFI_ADDRESS *)&mpi2IocInit->ReplyDescriptorPostQueueAddress;
382 mfiAddressTemp->u.addressLow = (uint32_t)phyAddress;
383 mfiAddressTemp->u.addressHigh = (uint32_t)((uint64_t)phyAddress >> 32);
384
385 /* Get physical address of request message pool */
386 offset = sc->request_message_pool_align - sc->request_message_pool;
387 phyAddress = sc->mfi_tb_busaddr + offset;
388 mfiAddressTemp = (MFI_ADDRESS *)&mpi2IocInit->SystemRequestFrameBaseAddress;
389 mfiAddressTemp->u.addressLow = (uint32_t)phyAddress;
390 mfiAddressTemp->u.addressHigh = (uint32_t)((uint64_t)phyAddress >> 32);
391 mpi2IocInit->ReplyFreeQueueAddress = 0; /* Not supported by MR. */
392 mpi2IocInit->TimeStamp = time_uptime;
393
394 if (sc->verbuf) {
395 snprintf((char *)sc->verbuf, strlen(MEGASAS_VERSION) + 2, "%s\n",
396 MEGASAS_VERSION);
397 mfi_init->driver_ver_lo = (uint32_t)sc->verbuf_h_busaddr;
398 mfi_init->driver_ver_hi =
399 (uint32_t)((uint64_t)sc->verbuf_h_busaddr >> 32);
400 }
401 /* Get the physical address of the mpi2 ioc init command */
402 phyAddress = sc->mfi_tb_ioc_init_busaddr;
403 mfi_init->qinfo_new_addr_lo = (uint32_t)phyAddress;
404 mfi_init->qinfo_new_addr_hi = (uint32_t)((uint64_t)phyAddress >> 32);
405 mfi_init->header.flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
406
407 mfi_init->header.cmd = MFI_CMD_INIT;
408 mfi_init->header.data_len = sizeof(struct MPI2_IOC_INIT_REQUEST);
409 mfi_init->header.cmd_status = MFI_STAT_INVALID_STATUS;
410
411 cm->cm_data = NULL;
412 cm->cm_flags |= MFI_CMD_POLLED;
413 cm->cm_timestamp = time_uptime;
414 if ((error = mfi_mapcmd(sc, cm)) != 0) {
415 device_printf(sc->mfi_dev, "failed to send IOC init2 "
416 "command %d at %lx\n", error, (long)cm->cm_frame_busaddr);
417 mfi_release_command(cm);
418 mtx_unlock(&sc->mfi_io_lock);
419 return (error);
420 }
421 mfi_release_command(cm);
422 mtx_unlock(&sc->mfi_io_lock);
423
424 if (mfi_init->header.cmd_status == 0) {
425 sc->MFA_enabled = 1;
426 }
427 else {
428 device_printf(sc->mfi_dev, "Init command Failed %x\n",
429 mfi_init->header.cmd_status);
430 return 1;
431 }
432
433 return 0;
434
435 }
436
437 int
438 mfi_tbolt_alloc_cmd(struct mfi_softc *sc)
439 {
440 struct mfi_cmd_tbolt *cmd;
441 bus_addr_t io_req_base_phys;
442 uint8_t *io_req_base;
443 int i = 0, j = 0, offset = 0;
444
445 /*
446 * sc->mfi_cmd_pool_tbolt is an array of struct mfi_cmd_tbolt pointers.
447 * Allocate the dynamic array first and then allocate individual
448 * commands.
449 */
450 sc->request_desc_pool = malloc(sizeof(
451 union mfi_mpi2_request_descriptor) * sc->mfi_max_fw_cmds,
452 M_MFIBUF, M_NOWAIT|M_ZERO);
453 sc->mfi_cmd_pool_tbolt = malloc(sizeof(struct mfi_cmd_tbolt*)
454 * sc->mfi_max_fw_cmds, M_MFIBUF, M_NOWAIT|M_ZERO);
455
456 if (!sc->mfi_cmd_pool_tbolt) {
457 device_printf(sc->mfi_dev, "out of memory. Could not alloc "
458 "memory for cmd_list_fusion\n");
459 return 1;
460 }
461
462 for (i = 0; i < sc->mfi_max_fw_cmds; i++) {
463 sc->mfi_cmd_pool_tbolt[i] = malloc(sizeof(
464 struct mfi_cmd_tbolt),M_MFIBUF, M_NOWAIT|M_ZERO);
465
466 if (!sc->mfi_cmd_pool_tbolt[i]) {
467 device_printf(sc->mfi_dev, "Could not alloc cmd list "
468 "fusion\n");
469
470 for (j = 0; j < i; j++)
471 free(sc->mfi_cmd_pool_tbolt[j], M_MFIBUF);
472
473 free(sc->mfi_cmd_pool_tbolt, M_MFIBUF);
474 sc->mfi_cmd_pool_tbolt = NULL;
475 }
476 }
477
478 /*
479 * The first 256 bytes (SMID 0) is not used. Don't add to the cmd
480 *list
481 */
482 io_req_base = sc->request_message_pool_align
483 + MEGASAS_THUNDERBOLT_NEW_MSG_SIZE;
484 io_req_base_phys = sc->request_msg_busaddr
485 + MEGASAS_THUNDERBOLT_NEW_MSG_SIZE;
486
487 /*
488 * Add all the commands to command pool (instance->cmd_pool)
489 */
490 /* SMID 0 is reserved. Set SMID/index from 1 */
491
492 for (i = 0; i < sc->mfi_max_fw_cmds; i++) {
493 cmd = sc->mfi_cmd_pool_tbolt[i];
494 offset = MEGASAS_THUNDERBOLT_NEW_MSG_SIZE * i;
495 cmd->index = i + 1;
496 cmd->request_desc = (union mfi_mpi2_request_descriptor *)
497 (sc->request_desc_pool + i);
498 cmd->io_request = (struct mfi_mpi2_request_raid_scsi_io *)
499 (io_req_base + offset);
500 cmd->io_request_phys_addr = io_req_base_phys + offset;
501 cmd->sg_frame = (MPI2_SGE_IO_UNION *)(sc->reply_pool_limit
502 + i * MEGASAS_MAX_SZ_CHAIN_FRAME);
503 cmd->sg_frame_phys_addr = sc->sg_frame_busaddr + i
504 * MEGASAS_MAX_SZ_CHAIN_FRAME;
505
506 TAILQ_INSERT_TAIL(&(sc->mfi_cmd_tbolt_tqh), cmd, next);
507 }
508 return 0;
509 }
510
511 int
512 mfi_tbolt_reset(struct mfi_softc *sc)
513 {
514 uint32_t fw_state;
515
516 mtx_lock(&sc->mfi_io_lock);
517 if (sc->hw_crit_error) {
518 device_printf(sc->mfi_dev, "HW CRITICAL ERROR\n");
519 mtx_unlock(&sc->mfi_io_lock);
520 return 1;
521 }
522
523 if (sc->mfi_flags & MFI_FLAGS_TBOLT) {
524 fw_state = sc->mfi_read_fw_status(sc);
525 if ((fw_state & MFI_FWSTATE_FAULT) == MFI_FWSTATE_FAULT) {
526 if ((sc->disableOnlineCtrlReset == 0)
527 && (sc->adpreset == 0)) {
528 device_printf(sc->mfi_dev, "Adapter RESET "
529 "condition is detected\n");
530 sc->adpreset = 1;
531 sc->issuepend_done = 0;
532 sc->MFA_enabled = 0;
533 sc->last_reply_idx = 0;
534 mfi_process_fw_state_chg_isr((void *) sc);
535 }
536 mtx_unlock(&sc->mfi_io_lock);
537 return 0;
538 }
539 }
540 mtx_unlock(&sc->mfi_io_lock);
541 return 1;
542 }
543
544 /*
545 * mfi_intr_tbolt - isr entry point
546 */
547 void
548 mfi_intr_tbolt(void *arg)
549 {
550 struct mfi_softc *sc = (struct mfi_softc *)arg;
551
552 if (sc->mfi_check_clear_intr(sc) == 1) {
553 return;
554 }
555 if (sc->mfi_detaching)
556 return;
557 mtx_lock(&sc->mfi_io_lock);
558 mfi_tbolt_complete_cmd(sc);
559 if (sc->mfi_flags & MFI_FLAGS_QFRZN)
560 sc->mfi_flags &= ~MFI_FLAGS_QFRZN;
561 mfi_startio(sc);
562 mtx_unlock(&sc->mfi_io_lock);
563 return;
564 }
565
566 /*
567 * map_cmd_status - Maps FW cmd status to OS cmd status
568 * @cmd : Pointer to cmd
569 * @status : status of cmd returned by FW
570 * @ext_status : ext status of cmd returned by FW
571 */
572
573 void
574 map_tbolt_cmd_status(struct mfi_command *mfi_cmd, uint8_t status,
575 uint8_t ext_status)
576 {
577
578 switch (status) {
579 case MFI_STAT_OK:
580 mfi_cmd->cm_frame->header.cmd_status = 0;
581 mfi_cmd->cm_frame->dcmd.header.cmd_status = 0;
582 break;
583
584 case MFI_STAT_SCSI_IO_FAILED:
585 case MFI_STAT_LD_INIT_IN_PROGRESS:
586 mfi_cmd->cm_frame->header.cmd_status = status;
587 mfi_cmd->cm_frame->header.scsi_status = ext_status;
588 mfi_cmd->cm_frame->dcmd.header.cmd_status = status;
589 mfi_cmd->cm_frame->dcmd.header.scsi_status
590 = ext_status;
591 break;
592
593 case MFI_STAT_SCSI_DONE_WITH_ERROR:
594 mfi_cmd->cm_frame->header.cmd_status = ext_status;
595 mfi_cmd->cm_frame->dcmd.header.cmd_status = ext_status;
596 break;
597
598 case MFI_STAT_LD_OFFLINE:
599 case MFI_STAT_DEVICE_NOT_FOUND:
600 mfi_cmd->cm_frame->header.cmd_status = status;
601 mfi_cmd->cm_frame->dcmd.header.cmd_status = status;
602 break;
603
604 default:
605 mfi_cmd->cm_frame->header.cmd_status = status;
606 mfi_cmd->cm_frame->dcmd.header.cmd_status = status;
607 break;
608 }
609 }
610
611 /*
612 * mfi_tbolt_return_cmd - Return a cmd to free command pool
613 * @instance: Adapter soft state
614 * @cmd: Command packet to be returned to free command pool
615 */
616 static inline void
617 mfi_tbolt_return_cmd(struct mfi_softc *sc, struct mfi_cmd_tbolt *cmd)
618 {
619 mtx_assert(&sc->mfi_io_lock, MA_OWNED);
620
621 TAILQ_INSERT_TAIL(&sc->mfi_cmd_tbolt_tqh, cmd, next);
622 }
623
624 void
625 mfi_tbolt_complete_cmd(struct mfi_softc *sc)
626 {
627 struct mfi_mpi2_reply_header *desc, *reply_desc;
628 struct mfi_command *cmd_mfi, *cmd_mfi_check; /* For MFA Cmds */
629 struct mfi_cmd_tbolt *cmd_tbolt;
630 uint16_t smid;
631 uint8_t reply_descript_type;
632 struct mfi_mpi2_request_raid_scsi_io *scsi_io_req;
633 uint32_t status, extStatus;
634 uint16_t num_completed;
635 union desc_value val;
636
637 desc = (struct mfi_mpi2_reply_header *)
638 ((uintptr_t)sc->reply_frame_pool_align
639 + sc->last_reply_idx * sc->reply_size);
640 reply_desc = desc;
641
642 if (!reply_desc)
643 device_printf(sc->mfi_dev, "reply desc is NULL!!\n");
644
645 reply_descript_type = reply_desc->ReplyFlags
646 & MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
647 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED)
648 return;
649
650 num_completed = 0;
651 val.word = ((union mfi_mpi2_reply_descriptor *)desc)->words;
652
653 /* Read Reply descriptor */
654 while ((val.u.low != 0xFFFFFFFF) && (val.u.high != 0xFFFFFFFF)) {
655 smid = reply_desc->SMID;
656 if (!smid || smid > sc->mfi_max_fw_cmds + 1) {
657 device_printf(sc->mfi_dev, "smid is %x. Cannot "
658 "proceed. Returning \n", smid);
659 return;
660 }
661
662 cmd_tbolt = sc->mfi_cmd_pool_tbolt[smid - 1];
663 cmd_mfi = &sc->mfi_commands[cmd_tbolt->sync_cmd_idx];
664 scsi_io_req = cmd_tbolt->io_request;
665
666 status = cmd_mfi->cm_frame->dcmd.header.cmd_status;
667 extStatus = cmd_mfi->cm_frame->dcmd.header.scsi_status;
668 map_tbolt_cmd_status(cmd_mfi, status, extStatus);
669
670 /* remove command from busy queue if not polled */
671 TAILQ_FOREACH(cmd_mfi_check, &sc->mfi_busy, cm_link) {
672 if (cmd_mfi_check == cmd_mfi) {
673 mfi_remove_busy(cmd_mfi);
674 break;
675 }
676 }
677 cmd_mfi->cm_error = 0;
678 mfi_complete(sc, cmd_mfi);
679 mfi_tbolt_return_cmd(sc, cmd_tbolt);
680
681 sc->last_reply_idx++;
682 if (sc->last_reply_idx >= sc->mfi_max_fw_cmds) {
683 MFI_WRITE4(sc, MFI_RPI, sc->last_reply_idx);
684 sc->last_reply_idx = 0;
685 }
686 /*set it back to all 0xfff.*/
687 ((union mfi_mpi2_reply_descriptor*)desc)->words =
688 ~((uint64_t)0x00);
689
690 num_completed++;
691
692 /* Get the next reply descriptor */
693 desc = (struct mfi_mpi2_reply_header *)
694 ((uintptr_t)sc->reply_frame_pool_align
695 + sc->last_reply_idx * sc->reply_size);
696 reply_desc = desc;
697 val.word = ((union mfi_mpi2_reply_descriptor*)desc)->words;
698 reply_descript_type = reply_desc->ReplyFlags
699 & MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
700 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED)
701 break;
702 }
703
704 if (!num_completed)
705 return;
706
707 /* update replyIndex to FW */
708 if (sc->last_reply_idx)
709 MFI_WRITE4(sc, MFI_RPI, sc->last_reply_idx);
710
711 return;
712 }
713
714 /*
715 * mfi_get_cmd - Get a command from the free pool
716 * @instance: Adapter soft state
717 *
718 * Returns a free command from the pool
719 */
720
721 struct mfi_cmd_tbolt *
722 mfi_tbolt_get_cmd(struct mfi_softc *sc)
723 {
724 struct mfi_cmd_tbolt *cmd = NULL;
725
726 mtx_assert(&sc->mfi_io_lock, MA_OWNED);
727
728 cmd = TAILQ_FIRST(&sc->mfi_cmd_tbolt_tqh);
729 TAILQ_REMOVE(&sc->mfi_cmd_tbolt_tqh, cmd, next);
730 memset((uint8_t *)cmd->sg_frame, 0, MEGASAS_MAX_SZ_CHAIN_FRAME);
731 memset((uint8_t *)cmd->io_request, 0,
732 MEGASAS_THUNDERBOLT_NEW_MSG_SIZE);
733 return cmd;
734 }
735
736 union mfi_mpi2_request_descriptor *
737 mfi_tbolt_get_request_descriptor(struct mfi_softc *sc, uint16_t index)
738 {
739 uint8_t *p;
740
741 if (index >= sc->mfi_max_fw_cmds) {
742 device_printf(sc->mfi_dev, "Invalid SMID (0x%x)request "
743 "for descriptor\n", index);
744 return NULL;
745 }
746 p = sc->request_desc_pool + sizeof(union mfi_mpi2_request_descriptor)
747 * index;
748 memset(p, 0, sizeof(union mfi_mpi2_request_descriptor));
749 return (union mfi_mpi2_request_descriptor *)p;
750 }
751
752
753 /* Used to build IOCTL cmd */
754 uint8_t
755 mfi_build_mpt_pass_thru(struct mfi_softc *sc, struct mfi_command *mfi_cmd)
756 {
757 MPI25_IEEE_SGE_CHAIN64 *mpi25_ieee_chain;
758 struct mfi_mpi2_request_raid_scsi_io *io_req;
759 struct mfi_cmd_tbolt *cmd;
760
761 cmd = mfi_tbolt_get_cmd(sc);
762 if (!cmd)
763 return EBUSY;
764 mfi_cmd->cm_extra_frames = cmd->index; /* Frame count used as SMID */
765 cmd->sync_cmd_idx = mfi_cmd->cm_index;
766 io_req = cmd->io_request;
767 mpi25_ieee_chain = (MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL.IeeeChain;
768
769 io_req->Function = MPI2_FUNCTION_PASSTHRU_IO_REQUEST;
770 io_req->SGLOffset0 = offsetof(struct mfi_mpi2_request_raid_scsi_io,
771 SGL) / 4;
772 io_req->ChainOffset = sc->chain_offset_value_for_mpt_ptmsg;
773
774 mpi25_ieee_chain->Address = mfi_cmd->cm_frame_busaddr;
775
776 /*
777 In MFI pass thru, nextChainOffset will always be zero to
778 indicate the end of the chain.
779 */
780 mpi25_ieee_chain->Flags= MPI2_IEEE_SGE_FLAGS_CHAIN_ELEMENT
781 | MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR;
782
783 /* setting the length to the maximum length */
784 mpi25_ieee_chain->Length = 1024;
785
786 return 0;
787 }
788
789 void
790 mfi_tbolt_build_ldio(struct mfi_softc *sc, struct mfi_command *mfi_cmd,
791 struct mfi_cmd_tbolt *cmd)
792 {
793 uint32_t start_lba_lo = 0, start_lba_hi = 0, device_id;
794 struct mfi_mpi2_request_raid_scsi_io *io_request;
795 struct IO_REQUEST_INFO io_info;
796
797 device_id = mfi_cmd->cm_frame->io.header.target_id;
798 io_request = cmd->io_request;
799 io_request->RaidContext.TargetID = device_id;
800 io_request->RaidContext.Status = 0;
801 io_request->RaidContext.exStatus =0;
802
803 start_lba_lo = mfi_cmd->cm_frame->io.lba_lo;
804 start_lba_hi = mfi_cmd->cm_frame->io.lba_hi;
805
806 memset(&io_info, 0, sizeof(struct IO_REQUEST_INFO));
807 io_info.ldStartBlock = ((uint64_t)start_lba_hi << 32) | start_lba_lo;
808 io_info.numBlocks = mfi_cmd->cm_frame->io.header.data_len;
809 io_info.ldTgtId = device_id;
810 if ((mfi_cmd->cm_frame->header.flags & MFI_FRAME_DIR_READ) ==
811 MFI_FRAME_DIR_READ)
812 io_info.isRead = 1;
813
814 io_request->RaidContext.timeoutValue
815 = MFI_FUSION_FP_DEFAULT_TIMEOUT;
816 io_request->Function = MPI2_FUNCTION_LD_IO_REQUEST;
817 io_request->DevHandle = device_id;
818 cmd->request_desc->header.RequestFlags
819 = (MFI_REQ_DESCRIPT_FLAGS_LD_IO
820 << MFI_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
821 if ((io_request->IoFlags == 6) && (io_info.numBlocks == 0))
822 io_request->RaidContext.RegLockLength = 0x100;
823 io_request->DataLength = mfi_cmd->cm_frame->io.header.data_len
824 * MFI_SECTOR_LEN;
825 }
826
827 int
828 mfi_tbolt_is_ldio(struct mfi_command *mfi_cmd)
829 {
830 if (mfi_cmd->cm_frame->header.cmd == MFI_CMD_LD_READ
831 || mfi_cmd->cm_frame->header.cmd == MFI_CMD_LD_WRITE)
832 return 1;
833 else
834 return 0;
835 }
836
837 int
838 mfi_tbolt_build_io(struct mfi_softc *sc, struct mfi_command *mfi_cmd,
839 struct mfi_cmd_tbolt *cmd)
840 {
841 uint32_t device_id;
842 uint32_t sge_count;
843 uint8_t cdb[32], cdb_len;
844
845 memset(cdb, 0, 32);
846 struct mfi_mpi2_request_raid_scsi_io *io_request = cmd->io_request;
847
848 device_id = mfi_cmd->cm_frame->header.target_id;
849
850 /* Have to build CDB here for TB as BSD don't have a scsi layer */
851 if ((cdb_len = mfi_tbolt_build_cdb(sc, mfi_cmd, cdb)) == 1)
852 return 1;
853
854 /* Just the CDB length,rest of the Flags are zero */
855 io_request->IoFlags = cdb_len;
856 memcpy(io_request->CDB.CDB32, cdb, 32);
857
858 if (mfi_tbolt_is_ldio(mfi_cmd))
859 mfi_tbolt_build_ldio(sc, mfi_cmd , cmd);
860 else
861 return 1;
862
863 /*
864 * Construct SGL
865 */
866 sge_count = mfi_tbolt_make_sgl(sc, mfi_cmd,
867 (pMpi25IeeeSgeChain64_t) &io_request->SGL, cmd);
868 if (sge_count > sc->mfi_max_sge) {
869 device_printf(sc->mfi_dev, "Error. sge_count (0x%x) exceeds "
870 "max (0x%x) allowed\n", sge_count, sc->mfi_max_sge);
871 return 1;
872 }
873 io_request->RaidContext.numSGE = sge_count;
874 io_request->SGLFlags = MPI2_SGE_FLAGS_64_BIT_ADDRESSING;
875
876 if (mfi_cmd->cm_frame->header.cmd == MFI_CMD_LD_WRITE)
877 io_request->Control = MPI2_SCSIIO_CONTROL_WRITE;
878 else
879 io_request->Control = MPI2_SCSIIO_CONTROL_READ;
880
881 io_request->SGLOffset0 = offsetof(
882 struct mfi_mpi2_request_raid_scsi_io, SGL)/4;
883
884 io_request->SenseBufferLowAddress = mfi_cmd->cm_sense_busaddr;
885 io_request->SenseBufferLength = MFI_SENSE_LEN;
886 return 0;
887 }
888
889 static int
890 mfi_tbolt_build_cdb(struct mfi_softc *sc, struct mfi_command *mfi_cmd,
891 uint8_t *cdb)
892 {
893 uint32_t lba_lo, lba_hi, num_lba;
894 uint8_t cdb_len;
895
896 if (mfi_cmd == NULL || cdb == NULL)
897 return 1;
898 num_lba = mfi_cmd->cm_frame->io.header.data_len;
899 lba_lo = mfi_cmd->cm_frame->io.lba_lo;
900 lba_hi = mfi_cmd->cm_frame->io.lba_hi;
901
902 if (lba_hi == 0 && (num_lba <= 0xFF) && (lba_lo <= 0x1FFFFF)) {
903 if (mfi_cmd->cm_frame->header.cmd == MFI_CMD_LD_WRITE)
904 /* Read 6 or Write 6 */
905 cdb[0] = (uint8_t) (0x0A);
906 else
907 cdb[0] = (uint8_t) (0x08);
908
909 cdb[4] = (uint8_t) num_lba;
910 cdb[3] = (uint8_t) (lba_lo & 0xFF);
911 cdb[2] = (uint8_t) (lba_lo >> 8);
912 cdb[1] = (uint8_t) ((lba_lo >> 16) & 0x1F);
913 cdb_len = 6;
914 }
915 else if (lba_hi == 0 && (num_lba <= 0xFFFF) && (lba_lo <= 0xFFFFFFFF)) {
916 if (mfi_cmd->cm_frame->header.cmd == MFI_CMD_LD_WRITE)
917 /* Read 10 or Write 10 */
918 cdb[0] = (uint8_t) (0x2A);
919 else
920 cdb[0] = (uint8_t) (0x28);
921 cdb[8] = (uint8_t) (num_lba & 0xFF);
922 cdb[7] = (uint8_t) (num_lba >> 8);
923 cdb[5] = (uint8_t) (lba_lo & 0xFF);
924 cdb[4] = (uint8_t) (lba_lo >> 8);
925 cdb[3] = (uint8_t) (lba_lo >> 16);
926 cdb[2] = (uint8_t) (lba_lo >> 24);
927 cdb_len = 10;
928 } else if ((num_lba > 0xFFFF) && (lba_hi == 0)) {
929 if (mfi_cmd->cm_frame->header.cmd == MFI_CMD_LD_WRITE)
930 /* Read 12 or Write 12 */
931 cdb[0] = (uint8_t) (0xAA);
932 else
933 cdb[0] = (uint8_t) (0xA8);
934 cdb[9] = (uint8_t) (num_lba & 0xFF);
935 cdb[8] = (uint8_t) (num_lba >> 8);
936 cdb[7] = (uint8_t) (num_lba >> 16);
937 cdb[6] = (uint8_t) (num_lba >> 24);
938 cdb[5] = (uint8_t) (lba_lo & 0xFF);
939 cdb[4] = (uint8_t) (lba_lo >> 8);
940 cdb[3] = (uint8_t) (lba_lo >> 16);
941 cdb[2] = (uint8_t) (lba_lo >> 24);
942 cdb_len = 12;
943 } else {
944 if (mfi_cmd->cm_frame->header.cmd == MFI_CMD_LD_WRITE)
945 cdb[0] = (uint8_t) (0x8A);
946 else
947 cdb[0] = (uint8_t) (0x88);
948 cdb[13] = (uint8_t) (num_lba & 0xFF);
949 cdb[12] = (uint8_t) (num_lba >> 8);
950 cdb[11] = (uint8_t) (num_lba >> 16);
951 cdb[10] = (uint8_t) (num_lba >> 24);
952 cdb[9] = (uint8_t) (lba_lo & 0xFF);
953 cdb[8] = (uint8_t) (lba_lo >> 8);
954 cdb[7] = (uint8_t) (lba_lo >> 16);
955 cdb[6] = (uint8_t) (lba_lo >> 24);
956 cdb[5] = (uint8_t) (lba_hi & 0xFF);
957 cdb[4] = (uint8_t) (lba_hi >> 8);
958 cdb[3] = (uint8_t) (lba_hi >> 16);
959 cdb[2] = (uint8_t) (lba_hi >> 24);
960 cdb_len = 16;
961 }
962 return cdb_len;
963 }
964
965 static int
966 mfi_tbolt_make_sgl(struct mfi_softc *sc, struct mfi_command *mfi_cmd,
967 pMpi25IeeeSgeChain64_t sgl_ptr, struct mfi_cmd_tbolt *cmd)
968 {
969 uint8_t i, sg_processed, sg_to_process;
970 uint8_t sge_count, sge_idx;
971 union mfi_sgl *os_sgl;
972
973 /*
974 * Return 0 if there is no data transfer
975 */
976 if (!mfi_cmd->cm_sg || !mfi_cmd->cm_len) {
977 device_printf(sc->mfi_dev, "Buffer empty \n");
978 return 0;
979 }
980 os_sgl = mfi_cmd->cm_sg;
981 sge_count = mfi_cmd->cm_frame->header.sg_count;
982
983 if (sge_count > sc->mfi_max_sge) {
984 device_printf(sc->mfi_dev, "sgl ptr %p sg_cnt %d \n",
985 os_sgl, sge_count);
986 return sge_count;
987 }
988
989 if (sge_count > sc->max_SGEs_in_main_message)
990 /* One element to store the chain info */
991 sge_idx = sc->max_SGEs_in_main_message - 1;
992 else
993 sge_idx = sge_count;
994
995 for (i = 0; i < sge_idx; i++) {
996 /*
997 * For 32bit BSD we are getting 32 bit SGL's from OS
998 * but FW only take 64 bit SGL's so copying from 32 bit
999 * SGL's to 64.
1000 */
1001 if (sc->mfi_flags & MFI_FLAGS_SKINNY) {
1002 sgl_ptr->Length = os_sgl->sg_skinny[i].len;
1003 sgl_ptr->Address = os_sgl->sg_skinny[i].addr;
1004 } else {
1005 sgl_ptr->Length = os_sgl->sg32[i].len;
1006 sgl_ptr->Address = os_sgl->sg32[i].addr;
1007 }
1008 sgl_ptr->Flags = 0;
1009 sgl_ptr++;
1010 cmd->io_request->ChainOffset = 0;
1011 }
1012
1013 sg_processed = i;
1014
1015 if (sg_processed < sge_count) {
1016 pMpi25IeeeSgeChain64_t sg_chain;
1017 sg_to_process = sge_count - sg_processed;
1018 cmd->io_request->ChainOffset =
1019 sc->chain_offset_value_for_main_message;
1020 sg_chain = sgl_ptr;
1021 /* Prepare chain element */
1022 sg_chain->NextChainOffset = 0;
1023 sg_chain->Flags = (MPI2_IEEE_SGE_FLAGS_CHAIN_ELEMENT |
1024 MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR);
1025 sg_chain->Length = (sizeof(MPI2_SGE_IO_UNION) *
1026 (sge_count - sg_processed));
1027 sg_chain->Address = cmd->sg_frame_phys_addr;
1028 sgl_ptr = (pMpi25IeeeSgeChain64_t)cmd->sg_frame;
1029 for (; i < sge_count; i++) {
1030 if (sc->mfi_flags & MFI_FLAGS_SKINNY) {
1031 sgl_ptr->Length = os_sgl->sg_skinny[i].len;
1032 sgl_ptr->Address = os_sgl->sg_skinny[i].addr;
1033 } else {
1034 sgl_ptr->Length = os_sgl->sg32[i].len;
1035 sgl_ptr->Address = os_sgl->sg32[i].addr;
1036 }
1037 sgl_ptr->Flags = 0;
1038 sgl_ptr++;
1039 }
1040 }
1041 return sge_count;
1042 }
1043
1044 union mfi_mpi2_request_descriptor *
1045 mfi_build_and_issue_cmd(struct mfi_softc *sc, struct mfi_command *mfi_cmd)
1046 {
1047 struct mfi_cmd_tbolt *cmd;
1048 union mfi_mpi2_request_descriptor *req_desc = NULL;
1049 uint16_t index;
1050 cmd = mfi_tbolt_get_cmd(sc);
1051 if (!cmd)
1052 return NULL;
1053 mfi_cmd->cm_extra_frames = cmd->index;
1054 cmd->sync_cmd_idx = mfi_cmd->cm_index;
1055
1056 index = cmd->index;
1057 req_desc = mfi_tbolt_get_request_descriptor(sc, index-1);
1058 if (mfi_tbolt_build_io(sc, mfi_cmd, cmd))
1059 return NULL;
1060 req_desc->header.SMID = index;
1061 return req_desc;
1062 }
1063
1064 union mfi_mpi2_request_descriptor *
1065 mfi_tbolt_build_mpt_cmd(struct mfi_softc *sc, struct mfi_command *cmd)
1066 {
1067 union mfi_mpi2_request_descriptor *req_desc = NULL;
1068 uint16_t index;
1069 if (mfi_build_mpt_pass_thru(sc, cmd)) {
1070 device_printf(sc->mfi_dev, "Couldn't build MFI pass thru "
1071 "cmd\n");
1072 return NULL;
1073 }
1074 /* For fusion the frame_count variable is used for SMID */
1075 index = cmd->cm_extra_frames;
1076
1077 req_desc = mfi_tbolt_get_request_descriptor(sc, index - 1);
1078 if (!req_desc)
1079 return NULL;
1080
1081 bzero(req_desc, sizeof(req_desc));
1082 req_desc->header.RequestFlags = (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
1083 MFI_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1084 req_desc->header.SMID = index;
1085 return req_desc;
1086 }
1087
1088 int
1089 mfi_tbolt_send_frame(struct mfi_softc *sc, struct mfi_command *cm)
1090 {
1091 struct mfi_frame_header *hdr;
1092 uint8_t *cdb;
1093 union mfi_mpi2_request_descriptor *req_desc = NULL;
1094 int tm = MFI_POLL_TIMEOUT_SECS * 1000;
1095
1096 hdr = &cm->cm_frame->header;
1097 cdb = cm->cm_frame->pass.cdb;
1098 if (sc->adpreset)
1099 return 1;
1100 if ((cm->cm_flags & MFI_CMD_POLLED) == 0) {
1101 cm->cm_timestamp = time_uptime;
1102 mfi_enqueue_busy(cm);
1103 }
1104 else { /* still get interrupts for it */
1105 hdr->cmd_status = MFI_STAT_INVALID_STATUS;
1106 hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
1107 }
1108
1109 if (hdr->cmd == MFI_CMD_PD_SCSI_IO) {
1110 /* check for inquiry commands coming from CLI */
1111 if (cdb[0] != 0x28 || cdb[0] != 0x2A) {
1112 if ((req_desc = mfi_tbolt_build_mpt_cmd(sc, cm)) ==
1113 NULL) {
1114 device_printf(sc->mfi_dev, "Mapping from MFI "
1115 "to MPT Failed \n");
1116 return 1;
1117 }
1118 }
1119 else
1120 device_printf(sc->mfi_dev, "DJA NA XXX SYSPDIO\n");
1121 }
1122 else if (hdr->cmd == MFI_CMD_LD_SCSI_IO ||
1123 hdr->cmd == MFI_CMD_LD_READ || hdr->cmd == MFI_CMD_LD_WRITE) {
1124 if ((req_desc = mfi_build_and_issue_cmd(sc, cm)) == NULL) {
1125 device_printf(sc->mfi_dev, "LDIO Failed \n");
1126 return 1;
1127 }
1128 } else
1129 if ((req_desc = mfi_tbolt_build_mpt_cmd(sc, cm)) == NULL) {
1130 device_printf(sc->mfi_dev, "Mapping from MFI to MPT "
1131 "Failed\n");
1132 return 1;
1133 }
1134 MFI_WRITE4(sc, MFI_ILQP, (req_desc->words & 0xFFFFFFFF));
1135 MFI_WRITE4(sc, MFI_IHQP, (req_desc->words >>0x20));
1136
1137 if ((cm->cm_flags & MFI_CMD_POLLED) == 0)
1138 return 0;
1139
1140 /* This is a polled command, so busy-wait for it to complete. */
1141 while (hdr->cmd_status == MFI_STAT_INVALID_STATUS) {
1142 DELAY(1000);
1143 tm -= 1;
1144 if (tm <= 0)
1145 break;
1146 }
1147
1148 if (hdr->cmd_status == MFI_STAT_INVALID_STATUS) {
1149 device_printf(sc->mfi_dev, "Frame %p timed out "
1150 "command 0x%X\n", hdr, cm->cm_frame->dcmd.opcode);
1151 return (ETIMEDOUT);
1152 }
1153 return 0;
1154 }
1155
1156 static void
1157 mfi_issue_pending_cmds_again (struct mfi_softc *sc)
1158 {
1159 struct mfi_command *cm, *tmp;
1160
1161 mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1162 TAILQ_FOREACH_REVERSE_SAFE(cm, &sc->mfi_busy, BUSYQ, cm_link, tmp) {
1163
1164 cm->retry_for_fw_reset++;
1165
1166 /*
1167 * If a command has continuously been tried multiple times
1168 * and causing a FW reset condition, no further recoveries
1169 * should be performed on the controller
1170 */
1171 if (cm->retry_for_fw_reset == 3) {
1172 device_printf(sc->mfi_dev, "megaraid_sas: command %d "
1173 "was tried multiple times during adapter reset"
1174 "Shutting down the HBA\n", cm->cm_index);
1175 mfi_kill_hba(sc);
1176 sc->hw_crit_error = 1;
1177 return;
1178 }
1179
1180 if ((cm->cm_flags & MFI_ON_MFIQ_BUSY) != 0) {
1181 struct mfi_cmd_tbolt *cmd;
1182 mfi_remove_busy(cm);
1183 cmd = sc->mfi_cmd_pool_tbolt[cm->cm_extra_frames -
1184 1 ];
1185 mfi_tbolt_return_cmd(sc, cmd);
1186 if ((cm->cm_flags & MFI_ON_MFIQ_MASK) == 0) {
1187 if (cm->cm_frame->dcmd.opcode !=
1188 MFI_DCMD_CTRL_EVENT_WAIT) {
1189 device_printf(sc->mfi_dev,
1190 "APJ ****requeue command %d \n",
1191 cm->cm_index);
1192 mfi_requeue_ready(cm);
1193 }
1194 }
1195 else
1196 mfi_release_command(cm);
1197 }
1198 }
1199 mfi_startio(sc);
1200 }
1201
1202 static void
1203 mfi_kill_hba (struct mfi_softc *sc)
1204 {
1205 if (sc->mfi_flags & MFI_FLAGS_TBOLT)
1206 MFI_WRITE4 (sc, 0x00,MFI_STOP_ADP);
1207 else
1208 MFI_WRITE4 (sc, MFI_IDB,MFI_STOP_ADP);
1209 }
1210
1211 static void
1212 mfi_process_fw_state_chg_isr(void *arg)
1213 {
1214 struct mfi_softc *sc= (struct mfi_softc *)arg;
1215 struct mfi_cmd_tbolt *cmd;
1216 int error, status;
1217
1218 if (sc->adpreset == 1) {
1219 device_printf(sc->mfi_dev, "First stage of FW reset "
1220 "initiated...\n");
1221
1222 sc->mfi_adp_reset(sc);
1223 sc->mfi_enable_intr(sc);
1224
1225 device_printf(sc->mfi_dev, "First stage of reset complete, "
1226 "second stage initiated...\n");
1227
1228 sc->adpreset = 2;
1229
1230 /* waiting for about 20 second before start the second init */
1231 for (int wait = 0; wait < 20000; wait++)
1232 DELAY(1000);
1233 device_printf(sc->mfi_dev, "Second stage of FW reset "
1234 "initiated...\n");
1235 while ((status = MFI_READ4(sc, MFI_RSR)) & 0x04);
1236
1237 sc->mfi_disable_intr(sc);
1238
1239 /* We expect the FW state to be READY */
1240 if (mfi_transition_firmware(sc)) {
1241 device_printf(sc->mfi_dev, "controller is not in "
1242 "ready state\n");
1243 mfi_kill_hba(sc);
1244 sc->hw_crit_error= 1;
1245 return ;
1246 }
1247 if ((error = mfi_tbolt_init_MFI_queue(sc)) != 0)
1248 return;
1249
1250 mtx_lock(&sc->mfi_io_lock);
1251
1252 sc->mfi_enable_intr(sc);
1253 sc->adpreset = 0;
1254 free(sc->mfi_aen_cm->cm_data, M_MFIBUF);
1255 mfi_remove_busy(sc->mfi_aen_cm);
1256 cmd = sc->mfi_cmd_pool_tbolt[sc->mfi_aen_cm->cm_extra_frames
1257 - 1];
1258 mfi_tbolt_return_cmd(sc, cmd);
1259 if (sc->mfi_aen_cm) {
1260 mfi_release_command(sc->mfi_aen_cm);
1261 sc->mfi_aen_cm = NULL;
1262 }
1263 if (sc->mfi_map_sync_cm) {
1264 mfi_release_command(sc->mfi_map_sync_cm);
1265 sc->mfi_map_sync_cm = NULL;
1266 }
1267 mfi_issue_pending_cmds_again(sc);
1268
1269 /*
1270 * Issue pending command can result in adapter being marked
1271 * dead because of too many re-tries. Check for that
1272 * condition before clearing the reset condition on the FW
1273 */
1274 if (!sc->hw_crit_error) {
1275 /*
1276 * Initiate AEN (Asynchronous Event Notification)
1277 */
1278 mfi_aen_setup(sc, sc->last_seq_num);
1279 sc->issuepend_done = 1;
1280 device_printf(sc->mfi_dev, "second stage of reset "
1281 "complete, FW is ready now.\n");
1282 } else {
1283 device_printf(sc->mfi_dev, "second stage of reset "
1284 "never completed, hba was marked offline.\n");
1285 }
1286 } else {
1287 device_printf(sc->mfi_dev, "mfi_process_fw_state_chg_isr "
1288 "called with unhandled value:%d\n", sc->adpreset);
1289 }
1290 mtx_unlock(&sc->mfi_io_lock);
1291 }
1292
1293 /*
1294 * The ThunderBolt HW has an option for the driver to directly
1295 * access the underlying disks and operate on the RAID. To
1296 * do this there needs to be a capability to keep the RAID controller
1297 * and driver in sync. The FreeBSD driver does not take advantage
1298 * of this feature since it adds a lot of complexity and slows down
1299 * performance. Performance is gained by using the controller's
1300 * cache etc.
1301 *
1302 * Even though this driver doesn't access the disks directly, an
1303 * AEN like command is used to inform the RAID firmware to "sync"
1304 * with all LD's via the MFI_DCMD_LD_MAP_GET_INFO command. This
1305 * command in write mode will return when the RAID firmware has
1306 * detected a change to the RAID state. Examples of this type
1307 * of change are removing a disk. Once the command returns then
1308 * the driver needs to acknowledge this and "sync" all LD's again.
1309 * This repeats until we shutdown. Then we need to cancel this
1310 * pending command.
1311 *
1312 * If this is not done right the RAID firmware will not remove a
1313 * pulled drive and the RAID won't go degraded etc. Effectively,
1314 * stopping any RAID mangement to functions.
1315 *
1316 * Doing another LD sync, requires the use of an event since the
1317 * driver needs to do a mfi_wait_command and can't do that in an
1318 * interrupt thread.
1319 *
1320 * The driver could get the RAID state via the MFI_DCMD_LD_MAP_GET_INFO
1321 * That requires a bunch of structure and it is simplier to just do
1322 * the MFI_DCMD_LD_GET_LIST versus walking the RAID map.
1323 */
1324
1325 void
1326 mfi_tbolt_sync_map_info(struct mfi_softc *sc)
1327 {
1328 int error = 0, i;
1329 struct mfi_command *cmd;
1330 struct mfi_dcmd_frame *dcmd;
1331 uint32_t context = 0;
1332 union mfi_ld_ref *ld_sync;
1333 size_t ld_size;
1334 struct mfi_frame_header *hdr;
1335 struct mfi_command *cm = NULL;
1336 struct mfi_ld_list *list = NULL;
1337
1338 if (sc->mfi_map_sync_cm != NULL || sc->cm_map_abort)
1339 return;
1340
1341 mtx_lock(&sc->mfi_io_lock);
1342 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_LD_GET_LIST,
1343 (void **)&list, sizeof(*list));
1344 if (error)
1345 goto out;
1346
1347 cm->cm_flags = MFI_CMD_POLLED | MFI_CMD_DATAIN;
1348 if (mfi_wait_command(sc, cm) != 0) {
1349 device_printf(sc->mfi_dev, "Failed to get device listing\n");
1350 goto out;
1351 }
1352
1353 hdr = &cm->cm_frame->header;
1354 if (hdr->cmd_status != MFI_STAT_OK) {
1355 device_printf(sc->mfi_dev, "MFI_DCMD_LD_GET_LIST failed %x\n",
1356 hdr->cmd_status);
1357 goto out;
1358 }
1359
1360 ld_size = sizeof(*ld_sync) * list->ld_count;
1361 mtx_unlock(&sc->mfi_io_lock);
1362 ld_sync = (union mfi_ld_ref *) malloc(ld_size, M_MFIBUF,
1363 M_WAITOK | M_ZERO);
1364 if (ld_sync == NULL) {
1365 device_printf(sc->mfi_dev, "Failed to allocate sync\n");
1366 goto out;
1367 }
1368 for (i = 0; i < list->ld_count; i++) {
1369 ld_sync[i].ref = list->ld_list[i].ld.ref;
1370 }
1371
1372 mtx_lock(&sc->mfi_io_lock);
1373 if ((cmd = mfi_dequeue_free(sc)) == NULL) {
1374 device_printf(sc->mfi_dev, "Failed to get command\n");
1375 free(ld_sync, M_MFIBUF);
1376 goto out;
1377 }
1378
1379 context = cmd->cm_frame->header.context;
1380 bzero(cmd->cm_frame, sizeof(union mfi_frame));
1381 cmd->cm_frame->header.context = context;
1382
1383 dcmd = &cmd->cm_frame->dcmd;
1384 bzero(dcmd->mbox, MFI_MBOX_SIZE);
1385 dcmd->header.cmd = MFI_CMD_DCMD;
1386 dcmd->header.flags = MFI_FRAME_DIR_WRITE;
1387 dcmd->header.timeout = 0;
1388 dcmd->header.data_len = ld_size;
1389 dcmd->header.scsi_status = 0;
1390 dcmd->opcode = MFI_DCMD_LD_MAP_GET_INFO;
1391 cmd->cm_sg = &dcmd->sgl;
1392 cmd->cm_total_frame_size = MFI_DCMD_FRAME_SIZE;
1393 cmd->cm_data = ld_sync;
1394 cmd->cm_private = ld_sync;
1395
1396 cmd->cm_len = ld_size;
1397 cmd->cm_complete = mfi_sync_map_complete;
1398 sc->mfi_map_sync_cm = cmd;
1399
1400 cmd->cm_flags = MFI_CMD_DATAOUT;
1401 cmd->cm_frame->dcmd.mbox[0] = list->ld_count;
1402 cmd->cm_frame->dcmd.mbox[1] = MFI_DCMD_MBOX_PEND_FLAG;
1403
1404 if ((error = mfi_mapcmd(sc, cmd)) != 0) {
1405 device_printf(sc->mfi_dev, "failed to send map sync\n");
1406 free(ld_sync, M_MFIBUF);
1407 sc->mfi_map_sync_cm = NULL;
1408 mfi_requeue_ready(cmd);
1409 goto out;
1410 }
1411
1412 out:
1413 if (list)
1414 free(list, M_MFIBUF);
1415 if (cm)
1416 mfi_release_command(cm);
1417 mtx_unlock(&sc->mfi_io_lock);
1418 }
1419
1420 static void
1421 mfi_sync_map_complete(struct mfi_command *cm)
1422 {
1423 struct mfi_frame_header *hdr;
1424 struct mfi_softc *sc;
1425 int aborted = 0;
1426
1427 sc = cm->cm_sc;
1428 mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1429
1430 hdr = &cm->cm_frame->header;
1431
1432 if (sc->mfi_map_sync_cm == NULL)
1433 return;
1434
1435 if (sc->cm_map_abort ||
1436 hdr->cmd_status == MFI_STAT_INVALID_STATUS) {
1437 sc->cm_map_abort = 0;
1438 aborted = 1;
1439 }
1440
1441 free(cm->cm_data, M_MFIBUF);
1442 sc->mfi_map_sync_cm = NULL;
1443 wakeup(&sc->mfi_map_sync_cm);
1444 mfi_release_command(cm);
1445
1446 /* set it up again so the driver can catch more events */
1447 if (!aborted) {
1448 mfi_queue_map_sync(sc);
1449 }
1450 }
1451
1452 static void
1453 mfi_queue_map_sync(struct mfi_softc *sc)
1454 {
1455 mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1456 taskqueue_enqueue(taskqueue_swi, &sc->mfi_map_sync_task);
1457 }
1458
1459 void
1460 mfi_handle_map_sync(void *context, int pending)
1461 {
1462 struct mfi_softc *sc;
1463
1464 sc = context;
1465 mfi_tbolt_sync_map_info(sc);
1466 }
Cache object: a405124d1046ab14d03b50645fe708bb
|